clang  3.9.0
SemaDecl.cpp
Go to the documentation of this file.
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 
15 #include "TypeLocBuilder.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/ASTLambda.h"
20 #include "clang/AST/CharUnits.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/DeclTemplate.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/StmtCXX.h"
28 #include "clang/Basic/Builtins.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()
37 #include "clang/Sema/DeclSpec.h"
40 #include "clang/Sema/Lookup.h"
42 #include "clang/Sema/Scope.h"
43 #include "clang/Sema/ScopeInfo.h"
44 #include "clang/Sema/Template.h"
45 #include "llvm/ADT/SmallString.h"
46 #include "llvm/ADT/Triple.h"
47 #include <algorithm>
48 #include <cstring>
49 #include <functional>
50 
51 using namespace clang;
52 using namespace sema;
53 
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 } // end anonymous namespace
93 
94 /// \brief Determine whether the token kind starts a simple-type-specifier.
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___float128:
112  case tok::kw_wchar_t:
113  case tok::kw_bool:
114  case tok::kw___underlying_type:
115  case tok::kw___auto_type:
116  return true;
117 
118  case tok::annot_typename:
119  case tok::kw_char16_t:
120  case tok::kw_char32_t:
121  case tok::kw_typeof:
122  case tok::annot_decltype:
123  case tok::kw_decltype:
124  return getLangOpts().CPlusPlus;
125 
126  default:
127  break;
128  }
129 
130  return false;
131 }
132 
133 namespace {
135  NotFound,
136  FoundNonType,
137  FoundType
138 };
139 } // end anonymous namespace
140 
141 /// \brief Tries to perform unqualified lookup of the type decls in bases for
142 /// dependent class.
143 /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
144 /// type decl, \a FoundType if only type decls are found.
147  SourceLocation NameLoc,
148  const CXXRecordDecl *RD) {
149  if (!RD->hasDefinition())
150  return UnqualifiedTypeNameLookupResult::NotFound;
151  // Look for type decls in base classes.
152  UnqualifiedTypeNameLookupResult FoundTypeDecl =
153  UnqualifiedTypeNameLookupResult::NotFound;
154  for (const auto &Base : RD->bases()) {
155  const CXXRecordDecl *BaseRD = nullptr;
156  if (auto *BaseTT = Base.getType()->getAs<TagType>())
157  BaseRD = BaseTT->getAsCXXRecordDecl();
158  else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
159  // Look for type decls in dependent base classes that have known primary
160  // templates.
161  if (!TST || !TST->isDependentType())
162  continue;
163  auto *TD = TST->getTemplateName().getAsTemplateDecl();
164  if (!TD)
165  continue;
166  if (auto *BasePrimaryTemplate =
167  dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
168  if (BasePrimaryTemplate->getCanonicalDecl() != RD->getCanonicalDecl())
169  BaseRD = BasePrimaryTemplate;
170  else if (auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
172  CTD->findPartialSpecialization(Base.getType()))
173  if (PS->getCanonicalDecl() != RD->getCanonicalDecl())
174  BaseRD = PS;
175  }
176  }
177  }
178  if (BaseRD) {
179  for (NamedDecl *ND : BaseRD->lookup(&II)) {
180  if (!isa<TypeDecl>(ND))
181  return UnqualifiedTypeNameLookupResult::FoundNonType;
182  FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
183  }
184  if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
185  switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
186  case UnqualifiedTypeNameLookupResult::FoundNonType:
187  return UnqualifiedTypeNameLookupResult::FoundNonType;
188  case UnqualifiedTypeNameLookupResult::FoundType:
189  FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
190  break;
191  case UnqualifiedTypeNameLookupResult::NotFound:
192  break;
193  }
194  }
195  }
196  }
197 
198  return FoundTypeDecl;
199 }
200 
202  const IdentifierInfo &II,
203  SourceLocation NameLoc) {
204  // Lookup in the parent class template context, if any.
205  const CXXRecordDecl *RD = nullptr;
206  UnqualifiedTypeNameLookupResult FoundTypeDecl =
207  UnqualifiedTypeNameLookupResult::NotFound;
208  for (DeclContext *DC = S.CurContext;
209  DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
210  DC = DC->getParent()) {
211  // Look for type decls in dependent base classes that have known primary
212  // templates.
213  RD = dyn_cast<CXXRecordDecl>(DC);
214  if (RD && RD->getDescribedClassTemplate())
215  FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
216  }
217  if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
218  return nullptr;
219 
220  // We found some types in dependent base classes. Recover as if the user
221  // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the
222  // lookup during template instantiation.
223  S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II;
224 
226  auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
227  cast<Type>(Context.getRecordType(RD)));
228  QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
229 
230  CXXScopeSpec SS;
231  SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
232 
234  DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
235  DepTL.setNameLoc(NameLoc);
237  DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
238  return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
239 }
240 
241 /// \brief If the identifier refers to a type name within this scope,
242 /// return the declaration of that type.
243 ///
244 /// This routine performs ordinary name lookup of the identifier II
245 /// within the given scope, with optional C++ scope specifier SS, to
246 /// determine whether the name refers to a type. If so, returns an
247 /// opaque pointer (actually a QualType) corresponding to that
248 /// type. Otherwise, returns NULL.
250  Scope *S, CXXScopeSpec *SS,
251  bool isClassName, bool HasTrailingDot,
252  ParsedType ObjectTypePtr,
253  bool IsCtorOrDtorName,
254  bool WantNontrivialTypeSourceInfo,
255  IdentifierInfo **CorrectedII) {
256  // Determine where we will perform name lookup.
257  DeclContext *LookupCtx = nullptr;
258  if (ObjectTypePtr) {
259  QualType ObjectType = ObjectTypePtr.get();
260  if (ObjectType->isRecordType())
261  LookupCtx = computeDeclContext(ObjectType);
262  } else if (SS && SS->isNotEmpty()) {
263  LookupCtx = computeDeclContext(*SS, false);
264 
265  if (!LookupCtx) {
266  if (isDependentScopeSpecifier(*SS)) {
267  // C++ [temp.res]p3:
268  // A qualified-id that refers to a type and in which the
269  // nested-name-specifier depends on a template-parameter (14.6.2)
270  // shall be prefixed by the keyword typename to indicate that the
271  // qualified-id denotes a type, forming an
272  // elaborated-type-specifier (7.1.5.3).
273  //
274  // We therefore do not perform any name lookup if the result would
275  // refer to a member of an unknown specialization.
276  if (!isClassName && !IsCtorOrDtorName)
277  return nullptr;
278 
279  // We know from the grammar that this name refers to a type,
280  // so build a dependent node to describe the type.
281  if (WantNontrivialTypeSourceInfo)
282  return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
283 
285  QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
286  II, NameLoc);
287  return ParsedType::make(T);
288  }
289 
290  return nullptr;
291  }
292 
293  if (!LookupCtx->isDependentContext() &&
294  RequireCompleteDeclContext(*SS, LookupCtx))
295  return nullptr;
296  }
297 
298  // FIXME: LookupNestedNameSpecifierName isn't the right kind of
299  // lookup for class-names.
300  LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
301  LookupOrdinaryName;
302  LookupResult Result(*this, &II, NameLoc, Kind);
303  if (LookupCtx) {
304  // Perform "qualified" name lookup into the declaration context we
305  // computed, which is either the type of the base of a member access
306  // expression or the declaration context associated with a prior
307  // nested-name-specifier.
308  LookupQualifiedName(Result, LookupCtx);
309 
310  if (ObjectTypePtr && Result.empty()) {
311  // C++ [basic.lookup.classref]p3:
312  // If the unqualified-id is ~type-name, the type-name is looked up
313  // in the context of the entire postfix-expression. If the type T of
314  // the object expression is of a class type C, the type-name is also
315  // looked up in the scope of class C. At least one of the lookups shall
316  // find a name that refers to (possibly cv-qualified) T.
317  LookupName(Result, S);
318  }
319  } else {
320  // Perform unqualified name lookup.
321  LookupName(Result, S);
322 
323  // For unqualified lookup in a class template in MSVC mode, look into
324  // dependent base classes where the primary class template is known.
325  if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
326  if (ParsedType TypeInBase =
327  recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
328  return TypeInBase;
329  }
330  }
331 
332  NamedDecl *IIDecl = nullptr;
333  switch (Result.getResultKind()) {
336  if (CorrectedII) {
337  TypoCorrection Correction = CorrectTypo(
338  Result.getLookupNameInfo(), Kind, S, SS,
339  llvm::make_unique<TypeNameValidatorCCC>(true, isClassName),
340  CTK_ErrorRecovery);
341  IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
342  TemplateTy Template;
343  bool MemberOfUnknownSpecialization;
345  TemplateName.setIdentifier(NewII, NameLoc);
346  NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
347  CXXScopeSpec NewSS, *NewSSPtr = SS;
348  if (SS && NNS) {
349  NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
350  NewSSPtr = &NewSS;
351  }
352  if (Correction && (NNS || NewII != &II) &&
353  // Ignore a correction to a template type as the to-be-corrected
354  // identifier is not a template (typo correction for template names
355  // is handled elsewhere).
356  !(getLangOpts().CPlusPlus && NewSSPtr &&
357  isTemplateName(S, *NewSSPtr, false, TemplateName, nullptr, false,
358  Template, MemberOfUnknownSpecialization))) {
359  ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
360  isClassName, HasTrailingDot, ObjectTypePtr,
361  IsCtorOrDtorName,
362  WantNontrivialTypeSourceInfo);
363  if (Ty) {
364  diagnoseTypo(Correction,
365  PDiag(diag::err_unknown_type_or_class_name_suggest)
366  << Result.getLookupName() << isClassName);
367  if (SS && NNS)
368  SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
369  *CorrectedII = NewII;
370  return Ty;
371  }
372  }
373  }
374  // If typo correction failed or was not performed, fall through
377  Result.suppressDiagnostics();
378  return nullptr;
379 
381  // Recover from type-hiding ambiguities by hiding the type. We'll
382  // do the lookup again when looking for an object, and we can
383  // diagnose the error then. If we don't do this, then the error
384  // about hiding the type will be immediately followed by an error
385  // that only makes sense if the identifier was treated like a type.
387  Result.suppressDiagnostics();
388  return nullptr;
389  }
390 
391  // Look to see if we have a type anywhere in the list of results.
392  for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
393  Res != ResEnd; ++Res) {
394  if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
395  if (!IIDecl ||
396  (*Res)->getLocation().getRawEncoding() <
397  IIDecl->getLocation().getRawEncoding())
398  IIDecl = *Res;
399  }
400  }
401 
402  if (!IIDecl) {
403  // None of the entities we found is a type, so there is no way
404  // to even assume that the result is a type. In this case, don't
405  // complain about the ambiguity. The parser will either try to
406  // perform this lookup again (e.g., as an object name), which
407  // will produce the ambiguity, or will complain that it expected
408  // a type name.
409  Result.suppressDiagnostics();
410  return nullptr;
411  }
412 
413  // We found a type within the ambiguous lookup; diagnose the
414  // ambiguity and then return that type. This might be the right
415  // answer, or it might not be, but it suppresses any attempt to
416  // perform the name lookup again.
417  break;
418 
419  case LookupResult::Found:
420  IIDecl = Result.getFoundDecl();
421  break;
422  }
423 
424  assert(IIDecl && "Didn't find decl");
425 
426  QualType T;
427  if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
428  DiagnoseUseOfDecl(IIDecl, NameLoc);
429 
430  T = Context.getTypeDeclType(TD);
431  MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
432 
433  // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
434  // constructor or destructor name (in such a case, the scope specifier
435  // will be attached to the enclosing Expr or Decl node).
436  if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) {
437  if (WantNontrivialTypeSourceInfo) {
438  // Construct a type with type-source information.
440  Builder.pushTypeSpec(T).setNameLoc(NameLoc);
441 
442  T = getElaboratedType(ETK_None, *SS, T);
443  ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
446  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
447  } else {
448  T = getElaboratedType(ETK_None, *SS, T);
449  }
450  }
451  } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
452  (void)DiagnoseUseOfDecl(IDecl, NameLoc);
453  if (!HasTrailingDot)
454  T = Context.getObjCInterfaceType(IDecl);
455  }
456 
457  if (T.isNull()) {
458  // If it's not plausibly a type, suppress diagnostics.
459  Result.suppressDiagnostics();
460  return nullptr;
461  }
462  return ParsedType::make(T);
463 }
464 
465 // Builds a fake NNS for the given decl context.
466 static NestedNameSpecifier *
468  for (;; DC = DC->getLookupParent()) {
469  DC = DC->getPrimaryContext();
470  auto *ND = dyn_cast<NamespaceDecl>(DC);
471  if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
472  return NestedNameSpecifier::Create(Context, nullptr, ND);
473  else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
474  return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
475  RD->getTypeForDecl());
476  else if (isa<TranslationUnitDecl>(DC))
477  return NestedNameSpecifier::GlobalSpecifier(Context);
478  }
479  llvm_unreachable("something isn't in TU scope?");
480 }
481 
482 /// Find the parent class with dependent bases of the innermost enclosing method
483 /// context. Do not look for enclosing CXXRecordDecls directly, or we will end
484 /// up allowing unqualified dependent type names at class-level, which MSVC
485 /// correctly rejects.
486 static const CXXRecordDecl *
488  for (; DC && DC->isDependentContext(); DC = DC->getLookupParent()) {
489  DC = DC->getPrimaryContext();
490  if (const auto *MD = dyn_cast<CXXMethodDecl>(DC))
491  if (MD->getParent()->hasAnyDependentBases())
492  return MD->getParent();
493  }
494  return nullptr;
495 }
496 
498  SourceLocation NameLoc,
499  bool IsTemplateTypeArg) {
500  assert(getLangOpts().MSVCCompat && "shouldn't be called in non-MSVC mode");
501 
502  NestedNameSpecifier *NNS = nullptr;
503  if (IsTemplateTypeArg && getCurScope()->isTemplateParamScope()) {
504  // If we weren't able to parse a default template argument, delay lookup
505  // until instantiation time by making a non-dependent DependentTypeName. We
506  // pretend we saw a NestedNameSpecifier referring to the current scope, and
507  // lookup is retried.
508  // FIXME: This hurts our diagnostic quality, since we get errors like "no
509  // type named 'Foo' in 'current_namespace'" when the user didn't write any
510  // name specifiers.
512  Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
513  } else if (const CXXRecordDecl *RD =
515  // Build a DependentNameType that will perform lookup into RD at
516  // instantiation time.
517  NNS = NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
518  RD->getTypeForDecl());
519 
520  // Diagnose that this identifier was undeclared, and retry the lookup during
521  // template instantiation.
522  Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
523  << RD;
524  } else {
525  // This is not a situation that we should recover from.
526  return ParsedType();
527  }
528 
530 
531  // Build type location information. We synthesized the qualifier, so we have
532  // to build a fake NestedNameSpecifierLoc.
533  NestedNameSpecifierLocBuilder NNSLocBuilder;
534  NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
535  NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
536 
538  DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
539  DepTL.setNameLoc(NameLoc);
541  DepTL.setQualifierLoc(QualifierLoc);
542  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
543 }
544 
545 /// isTagName() - This method is called *for error recovery purposes only*
546 /// to determine if the specified name is a valid tag name ("struct foo"). If
547 /// so, this returns the TST for the tag corresponding to it (TST_enum,
548 /// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose
549 /// cases in C where the user forgot to specify the tag.
551  // Do a tag name lookup in this scope.
552  LookupResult R(*this, &II, SourceLocation(), LookupTagName);
553  LookupName(R, S, false);
556  if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
557  switch (TD->getTagKind()) {
558  case TTK_Struct: return DeclSpec::TST_struct;
560  case TTK_Union: return DeclSpec::TST_union;
561  case TTK_Class: return DeclSpec::TST_class;
562  case TTK_Enum: return DeclSpec::TST_enum;
563  }
564  }
565 
567 }
568 
569 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
570 /// if a CXXScopeSpec's type is equal to the type of one of the base classes
571 /// then downgrade the missing typename error to a warning.
572 /// This is needed for MSVC compatibility; Example:
573 /// @code
574 /// template<class T> class A {
575 /// public:
576 /// typedef int TYPE;
577 /// };
578 /// template<class T> class B : public A<T> {
579 /// public:
580 /// A<T>::TYPE a; // no typename required because A<T> is a base class.
581 /// };
582 /// @endcode
584  if (CurContext->isRecord()) {
586  return true;
587 
588  const Type *Ty = SS->getScopeRep()->getAsType();
589 
590  CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
591  for (const auto &Base : RD->bases())
592  if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
593  return true;
594  return S->isFunctionPrototypeScope();
595  }
596  return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
597 }
598 
600  SourceLocation IILoc,
601  Scope *S,
602  CXXScopeSpec *SS,
603  ParsedType &SuggestedType,
604  bool AllowClassTemplates) {
605  // We don't have anything to suggest (yet).
606  SuggestedType = nullptr;
607 
608  // There may have been a typo in the name of the type. Look up typo
609  // results, in case we have something that we can suggest.
610  if (TypoCorrection Corrected =
611  CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS,
612  llvm::make_unique<TypeNameValidatorCCC>(
613  false, false, AllowClassTemplates),
614  CTK_ErrorRecovery)) {
615  if (Corrected.isKeyword()) {
616  // We corrected to a keyword.
617  diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II);
618  II = Corrected.getCorrectionAsIdentifierInfo();
619  } else {
620  // We found a similarly-named type or interface; suggest that.
621  if (!SS || !SS->isSet()) {
622  diagnoseTypo(Corrected,
623  PDiag(diag::err_unknown_typename_suggest) << II);
624  } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
625  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
626  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
627  II->getName().equals(CorrectedStr);
628  diagnoseTypo(Corrected,
629  PDiag(diag::err_unknown_nested_typename_suggest)
630  << II << DC << DroppedSpecifier << SS->getRange());
631  } else {
632  llvm_unreachable("could not have corrected a typo here");
633  }
634 
635  CXXScopeSpec tmpSS;
636  if (Corrected.getCorrectionSpecifier())
637  tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
638  SourceRange(IILoc));
639  SuggestedType =
640  getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
641  tmpSS.isSet() ? &tmpSS : SS, false, false, nullptr,
642  /*IsCtorOrDtorName=*/false,
643  /*NonTrivialTypeSourceInfo=*/true);
644  }
645  return;
646  }
647 
648  if (getLangOpts().CPlusPlus) {
649  // See if II is a class template that the user forgot to pass arguments to.
651  Name.setIdentifier(II, IILoc);
652  CXXScopeSpec EmptySS;
653  TemplateTy TemplateResult;
654  bool MemberOfUnknownSpecialization;
655  if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
656  Name, nullptr, true, TemplateResult,
657  MemberOfUnknownSpecialization) == TNK_Type_template) {
658  TemplateName TplName = TemplateResult.get();
659  Diag(IILoc, diag::err_template_missing_args) << TplName;
660  if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
661  Diag(TplDecl->getLocation(), diag::note_template_decl_here)
662  << TplDecl->getTemplateParameters()->getSourceRange();
663  }
664  return;
665  }
666  }
667 
668  // FIXME: Should we move the logic that tries to recover from a missing tag
669  // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
670 
671  if (!SS || (!SS->isSet() && !SS->isInvalid()))
672  Diag(IILoc, diag::err_unknown_typename) << II;
673  else if (DeclContext *DC = computeDeclContext(*SS, false))
674  Diag(IILoc, diag::err_typename_nested_not_found)
675  << II << DC << SS->getRange();
676  else if (isDependentScopeSpecifier(*SS)) {
677  unsigned DiagID = diag::err_typename_missing;
678  if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
679  DiagID = diag::ext_typename_missing;
680 
681  Diag(SS->getRange().getBegin(), DiagID)
682  << SS->getScopeRep() << II->getName()
683  << SourceRange(SS->getRange().getBegin(), IILoc)
684  << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
685  SuggestedType = ActOnTypenameType(S, SourceLocation(),
686  *SS, *II, IILoc).get();
687  } else {
688  assert(SS && SS->isInvalid() &&
689  "Invalid scope specifier has already been diagnosed");
690  }
691 }
692 
693 /// \brief Determine whether the given result set contains either a type name
694 /// or
695 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
696  bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
697  NextToken.is(tok::less);
698 
699  for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
700  if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
701  return true;
702 
703  if (CheckTemplate && isa<TemplateDecl>(*I))
704  return true;
705  }
706 
707  return false;
708 }
709 
710 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
711  Scope *S, CXXScopeSpec &SS,
713  SourceLocation NameLoc) {
714  LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
715  SemaRef.LookupParsedName(R, S, &SS);
716  if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
717  StringRef FixItTagName;
718  switch (Tag->getTagKind()) {
719  case TTK_Class:
720  FixItTagName = "class ";
721  break;
722 
723  case TTK_Enum:
724  FixItTagName = "enum ";
725  break;
726 
727  case TTK_Struct:
728  FixItTagName = "struct ";
729  break;
730 
731  case TTK_Interface:
732  FixItTagName = "__interface ";
733  break;
734 
735  case TTK_Union:
736  FixItTagName = "union ";
737  break;
738  }
739 
740  StringRef TagName = FixItTagName.drop_back();
741  SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
742  << Name << TagName << SemaRef.getLangOpts().CPlusPlus
743  << FixItHint::CreateInsertion(NameLoc, FixItTagName);
744 
745  for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
746  I != IEnd; ++I)
747  SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
748  << Name << TagName;
749 
750  // Replace lookup results with just the tag decl.
751  Result.clear(Sema::LookupTagName);
752  SemaRef.LookupParsedName(Result, S, &SS);
753  return true;
754  }
755 
756  return false;
757 }
758 
759 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
761  QualType T, SourceLocation NameLoc) {
763 
765  Builder.pushTypeSpec(T).setNameLoc(NameLoc);
766 
767  T = S.getElaboratedType(ETK_None, SS, T);
768  ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
770  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
771  return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
772 }
773 
776  SourceLocation NameLoc, const Token &NextToken,
777  bool IsAddressOfOperand,
778  std::unique_ptr<CorrectionCandidateCallback> CCC) {
779  DeclarationNameInfo NameInfo(Name, NameLoc);
780  ObjCMethodDecl *CurMethod = getCurMethodDecl();
781 
782  if (NextToken.is(tok::coloncolon)) {
783  BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
784  QualType(), false, SS, nullptr, false);
785  }
786 
787  LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
788  LookupParsedName(Result, S, &SS, !CurMethod);
789 
790  // For unqualified lookup in a class template in MSVC mode, look into
791  // dependent base classes where the primary class template is known.
792  if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
793  if (ParsedType TypeInBase =
794  recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
795  return TypeInBase;
796  }
797 
798  // Perform lookup for Objective-C instance variables (including automatically
799  // synthesized instance variables), if we're in an Objective-C method.
800  // FIXME: This lookup really, really needs to be folded in to the normal
801  // unqualified lookup mechanism.
802  if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
803  ExprResult E = LookupInObjCMethod(Result, S, Name, true);
804  if (E.get() || E.isInvalid())
805  return E;
806  }
807 
808  bool SecondTry = false;
809  bool IsFilteredTemplateName = false;
810 
811 Corrected:
812  switch (Result.getResultKind()) {
814  // If an unqualified-id is followed by a '(', then we have a function
815  // call.
816  if (!SS.isSet() && NextToken.is(tok::l_paren)) {
817  // In C++, this is an ADL-only call.
818  // FIXME: Reference?
819  if (getLangOpts().CPlusPlus)
820  return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
821 
822  // C90 6.3.2.2:
823  // If the expression that precedes the parenthesized argument list in a
824  // function call consists solely of an identifier, and if no
825  // declaration is visible for this identifier, the identifier is
826  // implicitly declared exactly as if, in the innermost block containing
827  // the function call, the declaration
828  //
829  // extern int identifier ();
830  //
831  // appeared.
832  //
833  // We also allow this in C99 as an extension.
834  if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
835  Result.addDecl(D);
836  Result.resolveKind();
837  return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
838  }
839  }
840 
841  // In C, we first see whether there is a tag type by the same name, in
842  // which case it's likely that the user just forgot to write "enum",
843  // "struct", or "union".
844  if (!getLangOpts().CPlusPlus && !SecondTry &&
845  isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
846  break;
847  }
848 
849  // Perform typo correction to determine if there is another name that is
850  // close to this name.
851  if (!SecondTry && CCC) {
852  SecondTry = true;
853  if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
854  Result.getLookupKind(), S,
855  &SS, std::move(CCC),
856  CTK_ErrorRecovery)) {
857  unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
858  unsigned QualifiedDiag = diag::err_no_member_suggest;
859 
860  NamedDecl *FirstDecl = Corrected.getFoundDecl();
861  NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
862  if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
863  UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
864  UnqualifiedDiag = diag::err_no_template_suggest;
865  QualifiedDiag = diag::err_no_member_template_suggest;
866  } else if (UnderlyingFirstDecl &&
867  (isa<TypeDecl>(UnderlyingFirstDecl) ||
868  isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
869  isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
870  UnqualifiedDiag = diag::err_unknown_typename_suggest;
871  QualifiedDiag = diag::err_unknown_nested_typename_suggest;
872  }
873 
874  if (SS.isEmpty()) {
875  diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
876  } else {// FIXME: is this even reachable? Test it.
877  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
878  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
879  Name->getName().equals(CorrectedStr);
880  diagnoseTypo(Corrected, PDiag(QualifiedDiag)
881  << Name << computeDeclContext(SS, false)
882  << DroppedSpecifier << SS.getRange());
883  }
884 
885  // Update the name, so that the caller has the new name.
886  Name = Corrected.getCorrectionAsIdentifierInfo();
887 
888  // Typo correction corrected to a keyword.
889  if (Corrected.isKeyword())
890  return Name;
891 
892  // Also update the LookupResult...
893  // FIXME: This should probably go away at some point
894  Result.clear();
895  Result.setLookupName(Corrected.getCorrection());
896  if (FirstDecl)
897  Result.addDecl(FirstDecl);
898 
899  // If we found an Objective-C instance variable, let
900  // LookupInObjCMethod build the appropriate expression to
901  // reference the ivar.
902  // FIXME: This is a gross hack.
903  if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
904  Result.clear();
905  ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
906  return E;
907  }
908 
909  goto Corrected;
910  }
911  }
912 
913  // We failed to correct; just fall through and let the parser deal with it.
914  Result.suppressDiagnostics();
916 
918  // We performed name lookup into the current instantiation, and there were
919  // dependent bases, so we treat this result the same way as any other
920  // dependent nested-name-specifier.
921 
922  // C++ [temp.res]p2:
923  // A name used in a template declaration or definition and that is
924  // dependent on a template-parameter is assumed not to name a type
925  // unless the applicable name lookup finds a type name or the name is
926  // qualified by the keyword typename.
927  //
928  // FIXME: If the next token is '<', we might want to ask the parser to
929  // perform some heroics to see if we actually have a
930  // template-argument-list, which would indicate a missing 'template'
931  // keyword here.
932  return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
933  NameInfo, IsAddressOfOperand,
934  /*TemplateArgs=*/nullptr);
935  }
936 
937  case LookupResult::Found:
940  break;
941 
943  if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
944  hasAnyAcceptableTemplateNames(Result)) {
945  // C++ [temp.local]p3:
946  // A lookup that finds an injected-class-name (10.2) can result in an
947  // ambiguity in certain cases (for example, if it is found in more than
948  // one base class). If all of the injected-class-names that are found
949  // refer to specializations of the same class template, and if the name
950  // is followed by a template-argument-list, the reference refers to the
951  // class template itself and not a specialization thereof, and is not
952  // ambiguous.
953  //
954  // This filtering can make an ambiguous result into an unambiguous one,
955  // so try again after filtering out template names.
956  FilterAcceptableTemplateNames(Result);
957  if (!Result.isAmbiguous()) {
958  IsFilteredTemplateName = true;
959  break;
960  }
961  }
962 
963  // Diagnose the ambiguity and return an error.
964  return NameClassification::Error();
965  }
966 
967  if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
968  (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
969  // C++ [temp.names]p3:
970  // After name lookup (3.4) finds that a name is a template-name or that
971  // an operator-function-id or a literal- operator-id refers to a set of
972  // overloaded functions any member of which is a function template if
973  // this is followed by a <, the < is always taken as the delimiter of a
974  // template-argument-list and never as the less-than operator.
975  if (!IsFilteredTemplateName)
976  FilterAcceptableTemplateNames(Result);
977 
978  if (!Result.empty()) {
979  bool IsFunctionTemplate;
980  bool IsVarTemplate;
981  TemplateName Template;
982  if (Result.end() - Result.begin() > 1) {
983  IsFunctionTemplate = true;
984  Template = Context.getOverloadedTemplateName(Result.begin(),
985  Result.end());
986  } else {
987  TemplateDecl *TD
988  = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
989  IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
990  IsVarTemplate = isa<VarTemplateDecl>(TD);
991 
992  if (SS.isSet() && !SS.isInvalid())
994  /*TemplateKeyword=*/false,
995  TD);
996  else
997  Template = TemplateName(TD);
998  }
999 
1000  if (IsFunctionTemplate) {
1001  // Function templates always go through overload resolution, at which
1002  // point we'll perform the various checks (e.g., accessibility) we need
1003  // to based on which function we selected.
1004  Result.suppressDiagnostics();
1005 
1006  return NameClassification::FunctionTemplate(Template);
1007  }
1008 
1009  return IsVarTemplate ? NameClassification::VarTemplate(Template)
1010  : NameClassification::TypeTemplate(Template);
1011  }
1012  }
1013 
1014  NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
1015  if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
1016  DiagnoseUseOfDecl(Type, NameLoc);
1017  MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
1019  if (SS.isNotEmpty())
1020  return buildNestedType(*this, SS, T, NameLoc);
1021  return ParsedType::make(T);
1022  }
1023 
1024  ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
1025  if (!Class) {
1026  // FIXME: It's unfortunate that we don't have a Type node for handling this.
1027  if (ObjCCompatibleAliasDecl *Alias =
1028  dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
1029  Class = Alias->getClassInterface();
1030  }
1031 
1032  if (Class) {
1033  DiagnoseUseOfDecl(Class, NameLoc);
1034 
1035  if (NextToken.is(tok::period)) {
1036  // Interface. <something> is parsed as a property reference expression.
1037  // Just return "unknown" as a fall-through for now.
1038  Result.suppressDiagnostics();
1039  return NameClassification::Unknown();
1040  }
1041 
1043  return ParsedType::make(T);
1044  }
1045 
1046  // We can have a type template here if we're classifying a template argument.
1047  if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl))
1048  return NameClassification::TypeTemplate(
1049  TemplateName(cast<TemplateDecl>(FirstDecl)));
1050 
1051  // Check for a tag type hidden by a non-type decl in a few cases where it
1052  // seems likely a type is wanted instead of the non-type that was found.
1053  bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star);
1054  if ((NextToken.is(tok::identifier) ||
1055  (NextIsOp &&
1056  FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1057  isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
1058  TypeDecl *Type = Result.getAsSingle<TypeDecl>();
1059  DiagnoseUseOfDecl(Type, NameLoc);
1060  QualType T = Context.getTypeDeclType(Type);
1061  if (SS.isNotEmpty())
1062  return buildNestedType(*this, SS, T, NameLoc);
1063  return ParsedType::make(T);
1064  }
1065 
1066  if (FirstDecl->isCXXClassMember())
1067  return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
1068  nullptr, S);
1069 
1070  bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1071  return BuildDeclarationNameExpr(SS, Result, ADL);
1072 }
1073 
1074 // Determines the context to return to after temporarily entering a
1075 // context. This depends in an unnecessarily complicated way on the
1076 // exact ordering of callbacks from the parser.
1078 
1079  // Functions defined inline within classes aren't parsed until we've
1080  // finished parsing the top-level class, so the top-level class is
1081  // the context we'll need to return to.
1082  // A Lambda call operator whose parent is a class must not be treated
1083  // as an inline member function. A Lambda can be used legally
1084  // either as an in-class member initializer or a default argument. These
1085  // are parsed once the class has been marked complete and so the containing
1086  // context would be the nested class (when the lambda is defined in one);
1087  // If the class is not complete, then the lambda is being used in an
1088  // ill-formed fashion (such as to specify the width of a bit-field, or
1089  // in an array-bound) - in which case we still want to return the
1090  // lexically containing DC (which could be a nested class).
1091  if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) {
1092  DC = DC->getLexicalParent();
1093 
1094  // A function not defined within a class will always return to its
1095  // lexical context.
1096  if (!isa<CXXRecordDecl>(DC))
1097  return DC;
1098 
1099  // A C++ inline method/friend is parsed *after* the topmost class
1100  // it was declared in is fully parsed ("complete"); the topmost
1101  // class is the context we need to return to.
1102  while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
1103  DC = RD;
1104 
1105  // Return the declaration context of the topmost class the inline method is
1106  // declared in.
1107  return DC;
1108  }
1109 
1110  return DC->getLexicalParent();
1111 }
1112 
1114  assert(getContainingDC(DC) == CurContext &&
1115  "The next DeclContext should be lexically contained in the current one.");
1116  CurContext = DC;
1117  S->setEntity(DC);
1118 }
1119 
1121  assert(CurContext && "DeclContext imbalance!");
1122 
1123  CurContext = getContainingDC(CurContext);
1124  assert(CurContext && "Popped translation unit!");
1125 }
1126 
1128  Decl *D) {
1129  // Unlike PushDeclContext, the context to which we return is not necessarily
1130  // the containing DC of TD, because the new context will be some pre-existing
1131  // TagDecl definition instead of a fresh one.
1132  auto Result = static_cast<SkippedDefinitionContext>(CurContext);
1133  CurContext = cast<TagDecl>(D)->getDefinition();
1134  assert(CurContext && "skipping definition of undefined tag");
1135  // Start lookups from the parent of the current context; we don't want to look
1136  // into the pre-existing complete definition.
1137  S->setEntity(CurContext->getLookupParent());
1138  return Result;
1139 }
1140 
1142  CurContext = static_cast<decltype(CurContext)>(Context);
1143 }
1144 
1145 /// EnterDeclaratorContext - Used when we must lookup names in the context
1146 /// of a declarator's nested name specifier.
1147 ///
1149  // C++0x [basic.lookup.unqual]p13:
1150  // A name used in the definition of a static data member of class
1151  // X (after the qualified-id of the static member) is looked up as
1152  // if the name was used in a member function of X.
1153  // C++0x [basic.lookup.unqual]p14:
1154  // If a variable member of a namespace is defined outside of the
1155  // scope of its namespace then any name used in the definition of
1156  // the variable member (after the declarator-id) is looked up as
1157  // if the definition of the variable member occurred in its
1158  // namespace.
1159  // Both of these imply that we should push a scope whose context
1160  // is the semantic context of the declaration. We can't use
1161  // PushDeclContext here because that context is not necessarily
1162  // lexically contained in the current context. Fortunately,
1163  // the containing scope should have the appropriate information.
1164 
1165  assert(!S->getEntity() && "scope already has entity");
1166 
1167 #ifndef NDEBUG
1168  Scope *Ancestor = S->getParent();
1169  while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1170  assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1171 #endif
1172 
1173  CurContext = DC;
1174  S->setEntity(DC);
1175 }
1176 
1178  assert(S->getEntity() == CurContext && "Context imbalance!");
1179 
1180  // Switch back to the lexical context. The safety of this is
1181  // enforced by an assert in EnterDeclaratorContext.
1182  Scope *Ancestor = S->getParent();
1183  while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1184  CurContext = Ancestor->getEntity();
1185 
1186  // We don't need to do anything with the scope, which is going to
1187  // disappear.
1188 }
1189 
1191  // We assume that the caller has already called
1192  // ActOnReenterTemplateScope so getTemplatedDecl() works.
1193  FunctionDecl *FD = D->getAsFunction();
1194  if (!FD)
1195  return;
1196 
1197  // Same implementation as PushDeclContext, but enters the context
1198  // from the lexical parent, rather than the top-level class.
1199  assert(CurContext == FD->getLexicalParent() &&
1200  "The next DeclContext should be lexically contained in the current one.");
1201  CurContext = FD;
1202  S->setEntity(CurContext);
1203 
1204  for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1205  ParmVarDecl *Param = FD->getParamDecl(P);
1206  // If the parameter has an identifier, then add it to the scope
1207  if (Param->getIdentifier()) {
1208  S->AddDecl(Param);
1209  IdResolver.AddDecl(Param);
1210  }
1211  }
1212 }
1213 
1215  // Same implementation as PopDeclContext, but returns to the lexical parent,
1216  // rather than the top-level class.
1217  assert(CurContext && "DeclContext imbalance!");
1218  CurContext = CurContext->getLexicalParent();
1219  assert(CurContext && "Popped translation unit!");
1220 }
1221 
1222 /// \brief Determine whether we allow overloading of the function
1223 /// PrevDecl with another declaration.
1224 ///
1225 /// This routine determines whether overloading is possible, not
1226 /// whether some new function is actually an overload. It will return
1227 /// true in C++ (where we can always provide overloads) or, as an
1228 /// extension, in C when the previous function is already an
1229 /// overloaded function declaration or has the "overloadable"
1230 /// attribute.
1232  ASTContext &Context) {
1233  if (Context.getLangOpts().CPlusPlus)
1234  return true;
1235 
1236  if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1237  return true;
1238 
1239  return (Previous.getResultKind() == LookupResult::Found
1240  && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
1241 }
1242 
1243 /// Add this decl to the scope shadowed decl chains.
1244 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
1245  // Move up the scope chain until we find the nearest enclosing
1246  // non-transparent context. The declaration will be introduced into this
1247  // scope.
1248  while (S->getEntity() && S->getEntity()->isTransparentContext())
1249  S = S->getParent();
1250 
1251  // Add scoped declarations into their context, so that they can be
1252  // found later. Declarations without a context won't be inserted
1253  // into any context.
1254  if (AddToContext)
1255  CurContext->addDecl(D);
1256 
1257  // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1258  // are function-local declarations.
1259  if (getLangOpts().CPlusPlus && D->isOutOfLine() &&
1260  !D->getDeclContext()->getRedeclContext()->Equals(
1261  D->getLexicalDeclContext()->getRedeclContext()) &&
1262  !D->getLexicalDeclContext()->isFunctionOrMethod())
1263  return;
1264 
1265  // Template instantiations should also not be pushed into scope.
1266  if (isa<FunctionDecl>(D) &&
1267  cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1268  return;
1269 
1270  // If this replaces anything in the current scope,
1271  IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1272  IEnd = IdResolver.end();
1273  for (; I != IEnd; ++I) {
1274  if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1275  S->RemoveDecl(*I);
1276  IdResolver.RemoveDecl(*I);
1277 
1278  // Should only need to replace one decl.
1279  break;
1280  }
1281  }
1282 
1283  S->AddDecl(D);
1284 
1285  if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1286  // Implicitly-generated labels may end up getting generated in an order that
1287  // isn't strictly lexical, which breaks name lookup. Be careful to insert
1288  // the label at the appropriate place in the identifier chain.
1289  for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1290  DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
1291  if (IDC == CurContext) {
1292  if (!S->isDeclScope(*I))
1293  continue;
1294  } else if (IDC->Encloses(CurContext))
1295  break;
1296  }
1297 
1298  IdResolver.InsertDeclAfter(I, D);
1299  } else {
1300  IdResolver.AddDecl(D);
1301  }
1302 }
1303 
1305  if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
1306  TUScope->AddDecl(D);
1307 }
1308 
1310  bool AllowInlineNamespace) {
1311  return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1312 }
1313 
1315  DeclContext *TargetDC = DC->getPrimaryContext();
1316  do {
1317  if (DeclContext *ScopeDC = S->getEntity())
1318  if (ScopeDC->getPrimaryContext() == TargetDC)
1319  return S;
1320  } while ((S = S->getParent()));
1321 
1322  return nullptr;
1323 }
1324 
1326  DeclContext*,
1327  ASTContext&);
1328 
1329 /// Filters out lookup results that don't fall within the given scope
1330 /// as determined by isDeclInScope.
1332  bool ConsiderLinkage,
1333  bool AllowInlineNamespace) {
1335  while (F.hasNext()) {
1336  NamedDecl *D = F.next();
1337 
1338  if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1339  continue;
1340 
1341  if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1342  continue;
1343 
1344  F.erase();
1345  }
1346 
1347  F.done();
1348 }
1349 
1350 static bool isUsingDecl(NamedDecl *D) {
1351  return isa<UsingShadowDecl>(D) ||
1352  isa<UnresolvedUsingTypenameDecl>(D) ||
1353  isa<UnresolvedUsingValueDecl>(D);
1354 }
1355 
1356 /// Removes using shadow declarations from the lookup results.
1359  while (F.hasNext())
1360  if (isUsingDecl(F.next()))
1361  F.erase();
1362 
1363  F.done();
1364 }
1365 
1366 /// \brief Check for this common pattern:
1367 /// @code
1368 /// class S {
1369 /// S(const S&); // DO NOT IMPLEMENT
1370 /// void operator=(const S&); // DO NOT IMPLEMENT
1371 /// };
1372 /// @endcode
1374  // FIXME: Should check for private access too but access is set after we get
1375  // the decl here.
1377  return false;
1378 
1379  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1380  return CD->isCopyConstructor();
1381  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1382  return Method->isCopyAssignmentOperator();
1383  return false;
1384 }
1385 
1386 // We need this to handle
1387 //
1388 // typedef struct {
1389 // void *foo() { return 0; }
1390 // } A;
1391 //
1392 // When we see foo we don't know if after the typedef we will get 'A' or '*A'
1393 // for example. If 'A', foo will have external linkage. If we have '*A',
1394 // foo will have no linkage. Since we can't know until we get to the end
1395 // of the typedef, this function finds out if D might have non-external linkage.
1396 // Callers should verify at the end of the TU if it D has external linkage or
1397 // not.
1398 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1399  const DeclContext *DC = D->getDeclContext();
1400  while (!DC->isTranslationUnit()) {
1401  if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1402  if (!RD->hasNameForLinkage())
1403  return true;
1404  }
1405  DC = DC->getParent();
1406  }
1407 
1408  return !D->isExternallyVisible();
1409 }
1410 
1411 // FIXME: This needs to be refactored; some other isInMainFile users want
1412 // these semantics.
1413 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1414  if (S.TUKind != TU_Complete)
1415  return false;
1416  return S.SourceMgr.isInMainFile(Loc);
1417 }
1418 
1420  assert(D);
1421 
1422  if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1423  return false;
1424 
1425  // Ignore all entities declared within templates, and out-of-line definitions
1426  // of members of class templates.
1427  if (D->getDeclContext()->isDependentContext() ||
1428  D->getLexicalDeclContext()->isDependentContext())
1429  return false;
1430 
1431  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1432  if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1433  return false;
1434 
1435  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1436  if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1437  return false;
1438  } else {
1439  // 'static inline' functions are defined in headers; don't warn.
1440  if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1441  return false;
1442  }
1443 
1444  if (FD->doesThisDeclarationHaveABody() &&
1446  return false;
1447  } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1448  // Constants and utility variables are defined in headers with internal
1449  // linkage; don't warn. (Unlike functions, there isn't a convenient marker
1450  // like "inline".)
1451  if (!isMainFileLoc(*this, VD->getLocation()))
1452  return false;
1453 
1454  if (Context.DeclMustBeEmitted(VD))
1455  return false;
1456 
1457  if (VD->isStaticDataMember() &&
1458  VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1459  return false;
1460 
1461  if (VD->isInline() && !isMainFileLoc(*this, VD->getLocation()))
1462  return false;
1463  } else {
1464  return false;
1465  }
1466 
1467  // Only warn for unused decls internal to the translation unit.
1468  // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1469  // for inline functions defined in the main source file, for instance.
1470  return mightHaveNonExternalLinkage(D);
1471 }
1472 
1474  if (!D)
1475  return;
1476 
1477  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1478  const FunctionDecl *First = FD->getFirstDecl();
1479  if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1480  return; // First should already be in the vector.
1481  }
1482 
1483  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1484  const VarDecl *First = VD->getFirstDecl();
1485  if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1486  return; // First should already be in the vector.
1487  }
1488 
1489  if (ShouldWarnIfUnusedFileScopedDecl(D))
1490  UnusedFileScopedDecls.push_back(D);
1491 }
1492 
1493 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
1494  if (D->isInvalidDecl())
1495  return false;
1496 
1497  if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() ||
1498  D->hasAttr<ObjCPreciseLifetimeAttr>())
1499  return false;
1500 
1501  if (isa<LabelDecl>(D))
1502  return true;
1503 
1504  // Except for labels, we only care about unused decls that are local to
1505  // functions.
1506  bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1507  if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1508  // For dependent types, the diagnostic is deferred.
1509  WithinFunction =
1510  WithinFunction || (R->isLocalClass() && !R->isDependentType());
1511  if (!WithinFunction)
1512  return false;
1513 
1514  if (isa<TypedefNameDecl>(D))
1515  return true;
1516 
1517  // White-list anything that isn't a local variable.
1518  if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
1519  return false;
1520 
1521  // Types of valid local variables should be complete, so this should succeed.
1522  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1523 
1524  // White-list anything with an __attribute__((unused)) type.
1525  QualType Ty = VD->getType();
1526 
1527  // Only look at the outermost level of typedef.
1528  if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1529  if (TT->getDecl()->hasAttr<UnusedAttr>())
1530  return false;
1531  }
1532 
1533  // If we failed to complete the type for some reason, or if the type is
1534  // dependent, don't diagnose the variable.
1535  if (Ty->isIncompleteType() || Ty->isDependentType())
1536  return false;
1537 
1538  if (const TagType *TT = Ty->getAs<TagType>()) {
1539  const TagDecl *Tag = TT->getDecl();
1540  if (Tag->hasAttr<UnusedAttr>())
1541  return false;
1542 
1543  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1544  if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1545  return false;
1546 
1547  if (const Expr *Init = VD->getInit()) {
1548  if (const ExprWithCleanups *Cleanups =
1549  dyn_cast<ExprWithCleanups>(Init))
1550  Init = Cleanups->getSubExpr();
1551  const CXXConstructExpr *Construct =
1552  dyn_cast<CXXConstructExpr>(Init);
1553  if (Construct && !Construct->isElidable()) {
1554  CXXConstructorDecl *CD = Construct->getConstructor();
1555  if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>())
1556  return false;
1557  }
1558  }
1559  }
1560  }
1561 
1562  // TODO: __attribute__((unused)) templates?
1563  }
1564 
1565  return true;
1566 }
1567 
1568 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1569  FixItHint &Hint) {
1570  if (isa<LabelDecl>(D)) {
1571  SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(),
1572  tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true);
1573  if (AfterColon.isInvalid())
1574  return;
1576  getCharRange(D->getLocStart(), AfterColon));
1577  }
1578 }
1579 
1581  if (D->getTypeForDecl()->isDependentType())
1582  return;
1583 
1584  for (auto *TmpD : D->decls()) {
1585  if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1586  DiagnoseUnusedDecl(T);
1587  else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1588  DiagnoseUnusedNestedTypedefs(R);
1589  }
1590 }
1591 
1592 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1593 /// unless they are marked attr(unused).
1595  if (!ShouldDiagnoseUnusedDecl(D))
1596  return;
1597 
1598  if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1599  // typedefs can be referenced later on, so the diagnostics are emitted
1600  // at end-of-translation-unit.
1601  UnusedLocalTypedefNameCandidates.insert(TD);
1602  return;
1603  }
1604 
1605  FixItHint Hint;
1607 
1608  unsigned DiagID;
1609  if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1610  DiagID = diag::warn_unused_exception_param;
1611  else if (isa<LabelDecl>(D))
1612  DiagID = diag::warn_unused_label;
1613  else
1614  DiagID = diag::warn_unused_variable;
1615 
1616  Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
1617 }
1618 
1619 static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1620  // Verify that we have no forward references left. If so, there was a goto
1621  // or address of a label taken, but no definition of it. Label fwd
1622  // definitions are indicated with a null substmt which is also not a resolved
1623  // MS inline assembly label name.
1624  bool Diagnose = false;
1625  if (L->isMSAsmLabel())
1626  Diagnose = !L->isResolvedMSAsmLabel();
1627  else
1628  Diagnose = L->getStmt() == nullptr;
1629  if (Diagnose)
1630  S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1631 }
1632 
1634  S->mergeNRVOIntoParent();
1635 
1636  if (S->decl_empty()) return;
1637  assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
1638  "Scope shouldn't contain decls!");
1639 
1640  for (auto *TmpD : S->decls()) {
1641  assert(TmpD && "This decl didn't get pushed??");
1642 
1643  assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1644  NamedDecl *D = cast<NamedDecl>(TmpD);
1645 
1646  if (!D->getDeclName()) continue;
1647 
1648  // Diagnose unused variables in this scope.
1649  if (!S->hasUnrecoverableErrorOccurred()) {
1650  DiagnoseUnusedDecl(D);
1651  if (const auto *RD = dyn_cast<RecordDecl>(D))
1652  DiagnoseUnusedNestedTypedefs(RD);
1653  }
1654 
1655  // If this was a forward reference to a label, verify it was defined.
1656  if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1657  CheckPoppedLabel(LD, *this);
1658 
1659  // Remove this name from our lexical scope, and warn on it if we haven't
1660  // already.
1661  IdResolver.RemoveDecl(D);
1662  auto ShadowI = ShadowingDecls.find(D);
1663  if (ShadowI != ShadowingDecls.end()) {
1664  if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
1665  Diag(D->getLocation(), diag::warn_ctor_parm_shadows_field)
1666  << D << FD << FD->getParent();
1667  Diag(FD->getLocation(), diag::note_previous_declaration);
1668  }
1669  ShadowingDecls.erase(ShadowI);
1670  }
1671  }
1672 }
1673 
1674 /// \brief Look for an Objective-C class in the translation unit.
1675 ///
1676 /// \param Id The name of the Objective-C class we're looking for. If
1677 /// typo-correction fixes this name, the Id will be updated
1678 /// to the fixed name.
1679 ///
1680 /// \param IdLoc The location of the name in the translation unit.
1681 ///
1682 /// \param DoTypoCorrection If true, this routine will attempt typo correction
1683 /// if there is no class with the given name.
1684 ///
1685 /// \returns The declaration of the named Objective-C class, or NULL if the
1686 /// class could not be found.
1688  SourceLocation IdLoc,
1689  bool DoTypoCorrection) {
1690  // The third "scope" argument is 0 since we aren't enabling lazy built-in
1691  // creation from this context.
1692  NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1693 
1694  if (!IDecl && DoTypoCorrection) {
1695  // Perform typo correction at the given location, but only if we
1696  // find an Objective-C class name.
1697  if (TypoCorrection C = CorrectTypo(
1698  DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr,
1699  llvm::make_unique<DeclFilterCCC<ObjCInterfaceDecl>>(),
1700  CTK_ErrorRecovery)) {
1701  diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1702  IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1703  Id = IDecl->getIdentifier();
1704  }
1705  }
1706  ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1707  // This routine must always return a class definition, if any.
1708  if (Def && Def->getDefinition())
1709  Def = Def->getDefinition();
1710  return Def;
1711 }
1712 
1713 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
1714 /// from S, where a non-field would be declared. This routine copes
1715 /// with the difference between C and C++ scoping rules in structs and
1716 /// unions. For example, the following code is well-formed in C but
1717 /// ill-formed in C++:
1718 /// @code
1719 /// struct S6 {
1720 /// enum { BAR } e;
1721 /// };
1722 ///
1723 /// void test_S6() {
1724 /// struct S6 a;
1725 /// a.e = BAR;
1726 /// }
1727 /// @endcode
1728 /// For the declaration of BAR, this routine will return a different
1729 /// scope. The scope S will be the scope of the unnamed enumeration
1730 /// within S6. In C++, this routine will return the scope associated
1731 /// with S6, because the enumeration's scope is a transparent
1732 /// context but structures can contain non-field names. In C, this
1733 /// routine will return the translation unit scope, since the
1734 /// enumeration's scope is a transparent context and structures cannot
1735 /// contain non-field names.
1737  while (((S->getFlags() & Scope::DeclScope) == 0) ||
1738  (S->getEntity() && S->getEntity()->isTransparentContext()) ||
1739  (S->isClassScope() && !getLangOpts().CPlusPlus))
1740  S = S->getParent();
1741  return S;
1742 }
1743 
1744 /// \brief Looks up the declaration of "struct objc_super" and
1745 /// saves it for later use in building builtin declaration of
1746 /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
1747 /// pre-existing declaration exists no action takes place.
1748 static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
1749  IdentifierInfo *II) {
1750  if (!II->isStr("objc_msgSendSuper"))
1751  return;
1752  ASTContext &Context = ThisSema.Context;
1753 
1754  LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
1756  ThisSema.LookupName(Result, S);
1757  if (Result.getResultKind() == LookupResult::Found)
1758  if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1759  Context.setObjCSuperType(Context.getTagDeclType(TD));
1760 }
1761 
1763  switch (Error) {
1764  case ASTContext::GE_None:
1765  return "";
1767  return "stdio.h";
1769  return "setjmp.h";
1771  return "ucontext.h";
1772  }
1773  llvm_unreachable("unhandled error kind");
1774 }
1775 
1776 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1777 /// file scope. lazily create a decl for it. ForRedeclaration is true
1778 /// if we're creating this built-in in anticipation of redeclaring the
1779 /// built-in.
1781  Scope *S, bool ForRedeclaration,
1782  SourceLocation Loc) {
1783  LookupPredefedObjCSuperType(*this, S, II);
1784 
1786  QualType R = Context.GetBuiltinType(ID, Error);
1787  if (Error) {
1788  if (ForRedeclaration)
1789  Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
1790  << getHeaderName(Error) << Context.BuiltinInfo.getName(ID);
1791  return nullptr;
1792  }
1793 
1794  if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(ID)) {
1795  Diag(Loc, diag::ext_implicit_lib_function_decl)
1796  << Context.BuiltinInfo.getName(ID) << R;
1797  if (Context.BuiltinInfo.getHeaderName(ID) &&
1798  !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc))
1799  Diag(Loc, diag::note_include_header_or_declare)
1801  << Context.BuiltinInfo.getName(ID);
1802  }
1803 
1804  if (R.isNull())
1805  return nullptr;
1806 
1808  if (getLangOpts().CPlusPlus) {
1809  LinkageSpecDecl *CLinkageDecl =
1810  LinkageSpecDecl::Create(Context, Parent, Loc, Loc,
1811  LinkageSpecDecl::lang_c, false);
1812  CLinkageDecl->setImplicit();
1813  Parent->addDecl(CLinkageDecl);
1814  Parent = CLinkageDecl;
1815  }
1816 
1818  Parent,
1819  Loc, Loc, II, R, /*TInfo=*/nullptr,
1820  SC_Extern,
1821  false,
1822  R->isFunctionProtoType());
1823  New->setImplicit();
1824 
1825  // Create Decl objects for each parameter, adding them to the
1826  // FunctionDecl.
1827  if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
1829  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1830  ParmVarDecl *parm =
1832  nullptr, FT->getParamType(i), /*TInfo=*/nullptr,
1833  SC_None, nullptr);
1834  parm->setScopeInfo(0, i);
1835  Params.push_back(parm);
1836  }
1837  New->setParams(Params);
1838  }
1839 
1840  AddKnownFunctionAttributes(New);
1841  RegisterLocallyScopedExternCDecl(New, S);
1842 
1843  // TUScope is the translation-unit scope to insert this function into.
1844  // FIXME: This is hideous. We need to teach PushOnScopeChains to
1845  // relate Scopes to DeclContexts, and probably eliminate CurContext
1846  // entirely, but we're not there yet.
1847  DeclContext *SavedContext = CurContext;
1848  CurContext = Parent;
1849  PushOnScopeChains(New, TUScope);
1850  CurContext = SavedContext;
1851  return New;
1852 }
1853 
1854 /// Typedef declarations don't have linkage, but they still denote the same
1855 /// entity if their types are the same.
1856 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's
1857 /// isSameEntity.
1861  // This is only interesting when modules are enabled.
1862  if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
1863  return;
1864 
1865  // Empty sets are uninteresting.
1866  if (Previous.empty())
1867  return;
1868 
1869  LookupResult::Filter Filter = Previous.makeFilter();
1870  while (Filter.hasNext()) {
1871  NamedDecl *Old = Filter.next();
1872 
1873  // Non-hidden declarations are never ignored.
1874  if (S.isVisible(Old))
1875  continue;
1876 
1877  // Declarations of the same entity are not ignored, even if they have
1878  // different linkages.
1879  if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
1880  if (S.Context.hasSameType(OldTD->getUnderlyingType(),
1881  Decl->getUnderlyingType()))
1882  continue;
1883 
1884  // If both declarations give a tag declaration a typedef name for linkage
1885  // purposes, then they declare the same entity.
1886  if (S.getLangOpts().CPlusPlus &&
1887  OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) &&
1889  continue;
1890  }
1891 
1892  Filter.erase();
1893  }
1894 
1895  Filter.done();
1896 }
1897 
1899  QualType OldType;
1900  if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
1901  OldType = OldTypedef->getUnderlyingType();
1902  else
1903  OldType = Context.getTypeDeclType(Old);
1904  QualType NewType = New->getUnderlyingType();
1905 
1906  if (NewType->isVariablyModifiedType()) {
1907  // Must not redefine a typedef with a variably-modified type.
1908  int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1909  Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
1910  << Kind << NewType;
1911  if (Old->getLocation().isValid())
1912  Diag(Old->getLocation(), diag::note_previous_definition);
1913  New->setInvalidDecl();
1914  return true;
1915  }
1916 
1917  if (OldType != NewType &&
1918  !OldType->isDependentType() &&
1919  !NewType->isDependentType() &&
1920  !Context.hasSameType(OldType, NewType)) {
1921  int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1922  Diag(New->getLocation(), diag::err_redefinition_different_typedef)
1923  << Kind << NewType << OldType;
1924  if (Old->getLocation().isValid())
1925  Diag(Old->getLocation(), diag::note_previous_definition);
1926  New->setInvalidDecl();
1927  return true;
1928  }
1929  return false;
1930 }
1931 
1932 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
1933 /// same name and scope as a previous declaration 'Old'. Figure out
1934 /// how to resolve this situation, merging decls or emitting
1935 /// diagnostics as appropriate. If there was an error, set New to be invalid.
1936 ///
1938  LookupResult &OldDecls) {
1939  // If the new decl is known invalid already, don't bother doing any
1940  // merging checks.
1941  if (New->isInvalidDecl()) return;
1942 
1943  // Allow multiple definitions for ObjC built-in typedefs.
1944  // FIXME: Verify the underlying types are equivalent!
1945  if (getLangOpts().ObjC1) {
1946  const IdentifierInfo *TypeID = New->getIdentifier();
1947  switch (TypeID->getLength()) {
1948  default: break;
1949  case 2:
1950  {
1951  if (!TypeID->isStr("id"))
1952  break;
1953  QualType T = New->getUnderlyingType();
1954  if (!T->isPointerType())
1955  break;
1956  if (!T->isVoidPointerType()) {
1957  QualType PT = T->getAs<PointerType>()->getPointeeType();
1958  if (!PT->isStructureType())
1959  break;
1960  }
1962  // Install the built-in type for 'id', ignoring the current definition.
1964  return;
1965  }
1966  case 5:
1967  if (!TypeID->isStr("Class"))
1968  break;
1970  // Install the built-in type for 'Class', ignoring the current definition.
1972  return;
1973  case 3:
1974  if (!TypeID->isStr("SEL"))
1975  break;
1977  // Install the built-in type for 'SEL', ignoring the current definition.
1979  return;
1980  }
1981  // Fall through - the typedef name was not a builtin type.
1982  }
1983 
1984  // Verify the old decl was also a type.
1985  TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1986  if (!Old) {
1987  Diag(New->getLocation(), diag::err_redefinition_different_kind)
1988  << New->getDeclName();
1989 
1990  NamedDecl *OldD = OldDecls.getRepresentativeDecl();
1991  if (OldD->getLocation().isValid())
1992  Diag(OldD->getLocation(), diag::note_previous_definition);
1993 
1994  return New->setInvalidDecl();
1995  }
1996 
1997  // If the old declaration is invalid, just give up here.
1998  if (Old->isInvalidDecl())
1999  return New->setInvalidDecl();
2000 
2001  if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2002  auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
2003  auto *NewTag = New->getAnonDeclWithTypedefName();
2004  NamedDecl *Hidden = nullptr;
2005  if (getLangOpts().CPlusPlus && OldTag && NewTag &&
2006  OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2007  !hasVisibleDefinition(OldTag, &Hidden)) {
2008  // There is a definition of this tag, but it is not visible. Use it
2009  // instead of our tag.
2010  New->setTypeForDecl(OldTD->getTypeForDecl());
2011  if (OldTD->isModed())
2012  New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
2013  OldTD->getUnderlyingType());
2014  else
2015  New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
2016 
2017  // Make the old tag definition visible.
2018  makeMergedDefinitionVisible(Hidden, NewTag->getLocation());
2019 
2020  // If this was an unscoped enumeration, yank all of its enumerators
2021  // out of the scope.
2022  if (isa<EnumDecl>(NewTag)) {
2023  Scope *EnumScope = getNonFieldDeclScope(S);
2024  for (auto *D : NewTag->decls()) {
2025  auto *ED = cast<EnumConstantDecl>(D);
2026  assert(EnumScope->isDeclScope(ED));
2027  EnumScope->RemoveDecl(ED);
2028  IdResolver.RemoveDecl(ED);
2029  ED->getLexicalDeclContext()->removeDecl(ED);
2030  }
2031  }
2032  }
2033  }
2034 
2035  // If the typedef types are not identical, reject them in all languages and
2036  // with any extensions enabled.
2037  if (isIncompatibleTypedef(Old, New))
2038  return;
2039 
2040  // The types match. Link up the redeclaration chain and merge attributes if
2041  // the old declaration was a typedef.
2042  if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
2043  New->setPreviousDecl(Typedef);
2044  mergeDeclAttributes(New, Old);
2045  }
2046 
2047  if (getLangOpts().MicrosoftExt)
2048  return;
2049 
2050  if (getLangOpts().CPlusPlus) {
2051  // C++ [dcl.typedef]p2:
2052  // In a given non-class scope, a typedef specifier can be used to
2053  // redefine the name of any type declared in that scope to refer
2054  // to the type to which it already refers.
2055  if (!isa<CXXRecordDecl>(CurContext))
2056  return;
2057 
2058  // C++0x [dcl.typedef]p4:
2059  // In a given class scope, a typedef specifier can be used to redefine
2060  // any class-name declared in that scope that is not also a typedef-name
2061  // to refer to the type to which it already refers.
2062  //
2063  // This wording came in via DR424, which was a correction to the
2064  // wording in DR56, which accidentally banned code like:
2065  //
2066  // struct S {
2067  // typedef struct A { } A;
2068  // };
2069  //
2070  // in the C++03 standard. We implement the C++0x semantics, which
2071  // allow the above but disallow
2072  //
2073  // struct S {
2074  // typedef int I;
2075  // typedef int I;
2076  // };
2077  //
2078  // since that was the intent of DR56.
2079  if (!isa<TypedefNameDecl>(Old))
2080  return;
2081 
2082  Diag(New->getLocation(), diag::err_redefinition)
2083  << New->getDeclName();
2084  Diag(Old->getLocation(), diag::note_previous_definition);
2085  return New->setInvalidDecl();
2086  }
2087 
2088  // Modules always permit redefinition of typedefs, as does C11.
2089  if (getLangOpts().Modules || getLangOpts().C11)
2090  return;
2091 
2092  // If we have a redefinition of a typedef in C, emit a warning. This warning
2093  // is normally mapped to an error, but can be controlled with
2094  // -Wtypedef-redefinition. If either the original or the redefinition is
2095  // in a system header, don't emit this for compatibility with GCC.
2096  if (getDiagnostics().getSuppressSystemWarnings() &&
2097  (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
2098  Context.getSourceManager().isInSystemHeader(New->getLocation())))
2099  return;
2100 
2101  Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
2102  << New->getDeclName();
2103  Diag(Old->getLocation(), diag::note_previous_definition);
2104 }
2105 
2106 /// DeclhasAttr - returns true if decl Declaration already has the target
2107 /// attribute.
2108 static bool DeclHasAttr(const Decl *D, const Attr *A) {
2109  const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2110  const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2111  for (const auto *i : D->attrs())
2112  if (i->getKind() == A->getKind()) {
2113  if (Ann) {
2114  if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2115  return true;
2116  continue;
2117  }
2118  // FIXME: Don't hardcode this check
2119  if (OA && isa<OwnershipAttr>(i))
2120  return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2121  return true;
2122  }
2123 
2124  return false;
2125 }
2126 
2128  if (VarDecl *VD = dyn_cast<VarDecl>(D))
2129  return VD->isThisDeclarationADefinition();
2130  if (TagDecl *TD = dyn_cast<TagDecl>(D))
2131  return TD->isCompleteDefinition() || TD->isBeingDefined();
2132  return true;
2133 }
2134 
2135 /// Merge alignment attributes from \p Old to \p New, taking into account the
2136 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2137 ///
2138 /// \return \c true if any attributes were added to \p New.
2139 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2140  // Look for alignas attributes on Old, and pick out whichever attribute
2141  // specifies the strictest alignment requirement.
2142  AlignedAttr *OldAlignasAttr = nullptr;
2143  AlignedAttr *OldStrictestAlignAttr = nullptr;
2144  unsigned OldAlign = 0;
2145  for (auto *I : Old->specific_attrs<AlignedAttr>()) {
2146  // FIXME: We have no way of representing inherited dependent alignments
2147  // in a case like:
2148  // template<int A, int B> struct alignas(A) X;
2149  // template<int A, int B> struct alignas(B) X {};
2150  // For now, we just ignore any alignas attributes which are not on the
2151  // definition in such a case.
2152  if (I->isAlignmentDependent())
2153  return false;
2154 
2155  if (I->isAlignas())
2156  OldAlignasAttr = I;
2157 
2158  unsigned Align = I->getAlignment(S.Context);
2159  if (Align > OldAlign) {
2160  OldAlign = Align;
2161  OldStrictestAlignAttr = I;
2162  }
2163  }
2164 
2165  // Look for alignas attributes on New.
2166  AlignedAttr *NewAlignasAttr = nullptr;
2167  unsigned NewAlign = 0;
2168  for (auto *I : New->specific_attrs<AlignedAttr>()) {
2169  if (I->isAlignmentDependent())
2170  return false;
2171 
2172  if (I->isAlignas())
2173  NewAlignasAttr = I;
2174 
2175  unsigned Align = I->getAlignment(S.Context);
2176  if (Align > NewAlign)
2177  NewAlign = Align;
2178  }
2179 
2180  if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2181  // Both declarations have 'alignas' attributes. We require them to match.
2182  // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2183  // fall short. (If two declarations both have alignas, they must both match
2184  // every definition, and so must match each other if there is a definition.)
2185 
2186  // If either declaration only contains 'alignas(0)' specifiers, then it
2187  // specifies the natural alignment for the type.
2188  if (OldAlign == 0 || NewAlign == 0) {
2189  QualType Ty;
2190  if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2191  Ty = VD->getType();
2192  else
2193  Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2194 
2195  if (OldAlign == 0)
2196  OldAlign = S.Context.getTypeAlign(Ty);
2197  if (NewAlign == 0)
2198  NewAlign = S.Context.getTypeAlign(Ty);
2199  }
2200 
2201  if (OldAlign != NewAlign) {
2202  S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2203  << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2204  << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2205  S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2206  }
2207  }
2208 
2209  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2210  // C++11 [dcl.align]p6:
2211  // if any declaration of an entity has an alignment-specifier,
2212  // every defining declaration of that entity shall specify an
2213  // equivalent alignment.
2214  // C11 6.7.5/7:
2215  // If the definition of an object does not have an alignment
2216  // specifier, any other declaration of that object shall also
2217  // have no alignment specifier.
2218  S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2219  << OldAlignasAttr;
2220  S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2221  << OldAlignasAttr;
2222  }
2223 
2224  bool AnyAdded = false;
2225 
2226  // Ensure we have an attribute representing the strictest alignment.
2227  if (OldAlign > NewAlign) {
2228  AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2229  Clone->setInherited(true);
2230  New->addAttr(Clone);
2231  AnyAdded = true;
2232  }
2233 
2234  // Ensure we have an alignas attribute if the old declaration had one.
2235  if (OldAlignasAttr && !NewAlignasAttr &&
2236  !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2237  AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2238  Clone->setInherited(true);
2239  New->addAttr(Clone);
2240  AnyAdded = true;
2241  }
2242 
2243  return AnyAdded;
2244 }
2245 
2247  const InheritableAttr *Attr,
2249  InheritableAttr *NewAttr = nullptr;
2250  unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
2251  if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2252  NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2253  AA->isImplicit(), AA->getIntroduced(),
2254  AA->getDeprecated(),
2255  AA->getObsoleted(), AA->getUnavailable(),
2256  AA->getMessage(), AA->getStrict(),
2257  AA->getReplacement(), AMK,
2258  AttrSpellingListIndex);
2259  else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2260  NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2261  AttrSpellingListIndex);
2262  else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2263  NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2264  AttrSpellingListIndex);
2265  else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2266  NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2267  AttrSpellingListIndex);
2268  else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2269  NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2270  AttrSpellingListIndex);
2271  else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2272  NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2273  FA->getFormatIdx(), FA->getFirstArg(),
2274  AttrSpellingListIndex);
2275  else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2276  NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2277  AttrSpellingListIndex);
2278  else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2279  NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2280  AttrSpellingListIndex,
2281  IA->getSemanticSpelling());
2282  else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
2283  NewAttr = S.mergeAlwaysInlineAttr(D, AA->getRange(),
2284  &S.Context.Idents.get(AA->getSpelling()),
2285  AttrSpellingListIndex);
2286  else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2287  NewAttr = S.mergeMinSizeAttr(D, MA->getRange(), AttrSpellingListIndex);
2288  else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2289  NewAttr = S.mergeOptimizeNoneAttr(D, OA->getRange(), AttrSpellingListIndex);
2290  else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr))
2291  NewAttr = S.mergeInternalLinkageAttr(
2292  D, InternalLinkageA->getRange(),
2293  &S.Context.Idents.get(InternalLinkageA->getSpelling()),
2294  AttrSpellingListIndex);
2295  else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr))
2296  NewAttr = S.mergeCommonAttr(D, CommonA->getRange(),
2297  &S.Context.Idents.get(CommonA->getSpelling()),
2298  AttrSpellingListIndex);
2299  else if (isa<AlignedAttr>(Attr))
2300  // AlignedAttrs are handled separately, because we need to handle all
2301  // such attributes on a declaration at the same time.
2302  NewAttr = nullptr;
2303  else if ((isa<DeprecatedAttr>(Attr) || isa<UnavailableAttr>(Attr)) &&
2304  (AMK == Sema::AMK_Override ||
2306  NewAttr = nullptr;
2307  else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr))
2308  NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2309 
2310  if (NewAttr) {
2311  NewAttr->setInherited(true);
2312  D->addAttr(NewAttr);
2313  if (isa<MSInheritanceAttr>(NewAttr))
2314  S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
2315  return true;
2316  }
2317 
2318  return false;
2319 }
2320 
2321 static const Decl *getDefinition(const Decl *D) {
2322  if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2323  return TD->getDefinition();
2324  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2325  const VarDecl *Def = VD->getDefinition();
2326  if (Def)
2327  return Def;
2328  return VD->getActingDefinition();
2329  }
2330  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2331  return FD->getDefinition();
2332  return nullptr;
2333 }
2334 
2335 static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2336  for (const auto *Attribute : D->attrs())
2337  if (Attribute->getKind() == Kind)
2338  return true;
2339  return false;
2340 }
2341 
2342 /// checkNewAttributesAfterDef - If we already have a definition, check that
2343 /// there are no new attributes in this declaration.
2344 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2345  if (!New->hasAttrs())
2346  return;
2347 
2348  const Decl *Def = getDefinition(Old);
2349  if (!Def || Def == New)
2350  return;
2351 
2352  AttrVec &NewAttributes = New->getAttrs();
2353  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2354  const Attr *NewAttribute = NewAttributes[I];
2355 
2356  if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
2357  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
2358  Sema::SkipBodyInfo SkipBody;
2359  S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
2360 
2361  // If we're skipping this definition, drop the "alias" attribute.
2362  if (SkipBody.ShouldSkip) {
2363  NewAttributes.erase(NewAttributes.begin() + I);
2364  --E;
2365  continue;
2366  }
2367  } else {
2368  VarDecl *VD = cast<VarDecl>(New);
2369  unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2371  ? diag::err_alias_after_tentative
2372  : diag::err_redefinition;
2373  S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2374  S.Diag(Def->getLocation(), diag::note_previous_definition);
2375  VD->setInvalidDecl();
2376  }
2377  ++I;
2378  continue;
2379  }
2380 
2381  if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2382  // Tentative definitions are only interesting for the alias check above.
2383  if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2384  ++I;
2385  continue;
2386  }
2387  }
2388 
2389  if (hasAttribute(Def, NewAttribute->getKind())) {
2390  ++I;
2391  continue; // regular attr merging will take care of validating this.
2392  }
2393 
2394  if (isa<C11NoReturnAttr>(NewAttribute)) {
2395  // C's _Noreturn is allowed to be added to a function after it is defined.
2396  ++I;
2397  continue;
2398  } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2399  if (AA->isAlignas()) {
2400  // C++11 [dcl.align]p6:
2401  // if any declaration of an entity has an alignment-specifier,
2402  // every defining declaration of that entity shall specify an
2403  // equivalent alignment.
2404  // C11 6.7.5/7:
2405  // If the definition of an object does not have an alignment
2406  // specifier, any other declaration of that object shall also
2407  // have no alignment specifier.
2408  S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2409  << AA;
2410  S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2411  << AA;
2412  NewAttributes.erase(NewAttributes.begin() + I);
2413  --E;
2414  continue;
2415  }
2416  }
2417 
2418  S.Diag(NewAttribute->getLocation(),
2419  diag::warn_attribute_precede_definition);
2420  S.Diag(Def->getLocation(), diag::note_previous_definition);
2421  NewAttributes.erase(NewAttributes.begin() + I);
2422  --E;
2423  }
2424 }
2425 
2426 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2428  AvailabilityMergeKind AMK) {
2429  if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2430  UsedAttr *NewAttr = OldAttr->clone(Context);
2431  NewAttr->setInherited(true);
2432  New->addAttr(NewAttr);
2433  }
2434 
2435  if (!Old->hasAttrs() && !New->hasAttrs())
2436  return;
2437 
2438  // Attributes declared post-definition are currently ignored.
2439  checkNewAttributesAfterDef(*this, New, Old);
2440 
2441  if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) {
2442  if (AsmLabelAttr *OldA = Old->getAttr<AsmLabelAttr>()) {
2443  if (OldA->getLabel() != NewA->getLabel()) {
2444  // This redeclaration changes __asm__ label.
2445  Diag(New->getLocation(), diag::err_different_asm_label);
2446  Diag(OldA->getLocation(), diag::note_previous_declaration);
2447  }
2448  } else if (Old->isUsed()) {
2449  // This redeclaration adds an __asm__ label to a declaration that has
2450  // already been ODR-used.
2451  Diag(New->getLocation(), diag::err_late_asm_label_name)
2452  << isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange();
2453  }
2454  }
2455 
2456  // Re-declaration cannot add abi_tag's.
2457  if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {
2458  if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
2459  for (const auto &NewTag : NewAbiTagAttr->tags()) {
2460  if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(),
2461  NewTag) == OldAbiTagAttr->tags_end()) {
2462  Diag(NewAbiTagAttr->getLocation(),
2463  diag::err_new_abi_tag_on_redeclaration)
2464  << NewTag;
2465  Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
2466  }
2467  }
2468  } else {
2469  Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
2470  Diag(Old->getLocation(), diag::note_previous_declaration);
2471  }
2472  }
2473 
2474  if (!Old->hasAttrs())
2475  return;
2476 
2477  bool foundAny = New->hasAttrs();
2478 
2479  // Ensure that any moving of objects within the allocated map is done before
2480  // we process them.
2481  if (!foundAny) New->setAttrs(AttrVec());
2482 
2483  for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2484  // Ignore deprecated/unavailable/availability attributes if requested.
2485  AvailabilityMergeKind LocalAMK = AMK_None;
2486  if (isa<DeprecatedAttr>(I) ||
2487  isa<UnavailableAttr>(I) ||
2488  isa<AvailabilityAttr>(I)) {
2489  switch (AMK) {
2490  case AMK_None:
2491  continue;
2492 
2493  case AMK_Redeclaration:
2494  case AMK_Override:
2495  case AMK_ProtocolImplementation:
2496  LocalAMK = AMK;
2497  break;
2498  }
2499  }
2500 
2501  // Already handled.
2502  if (isa<UsedAttr>(I))
2503  continue;
2504 
2505  if (mergeDeclAttribute(*this, New, I, LocalAMK))
2506  foundAny = true;
2507  }
2508 
2509  if (mergeAlignedAttrs(*this, New, Old))
2510  foundAny = true;
2511 
2512  if (!foundAny) New->dropAttrs();
2513 }
2514 
2515 /// mergeParamDeclAttributes - Copy attributes from the old parameter
2516 /// to the new one.
2518  const ParmVarDecl *oldDecl,
2519  Sema &S) {
2520  // C++11 [dcl.attr.depend]p2:
2521  // The first declaration of a function shall specify the
2522  // carries_dependency attribute for its declarator-id if any declaration
2523  // of the function specifies the carries_dependency attribute.
2524  const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2525  if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2526  S.Diag(CDA->getLocation(),
2527  diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2528  // Find the first declaration of the parameter.
2529  // FIXME: Should we build redeclaration chains for function parameters?
2530  const FunctionDecl *FirstFD =
2531  cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2532  const ParmVarDecl *FirstVD =
2533  FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2534  S.Diag(FirstVD->getLocation(),
2535  diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2536  }
2537 
2538  if (!oldDecl->hasAttrs())
2539  return;
2540 
2541  bool foundAny = newDecl->hasAttrs();
2542 
2543  // Ensure that any moving of objects within the allocated map is
2544  // done before we process them.
2545  if (!foundAny) newDecl->setAttrs(AttrVec());
2546 
2547  for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2548  if (!DeclHasAttr(newDecl, I)) {
2549  InheritableAttr *newAttr =
2550  cast<InheritableParamAttr>(I->clone(S.Context));
2551  newAttr->setInherited(true);
2552  newDecl->addAttr(newAttr);
2553  foundAny = true;
2554  }
2555  }
2556 
2557  if (!foundAny) newDecl->dropAttrs();
2558 }
2559 
2560 static void mergeParamDeclTypes(ParmVarDecl *NewParam,
2561  const ParmVarDecl *OldParam,
2562  Sema &S) {
2563  if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
2564  if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
2565  if (*Oldnullability != *Newnullability) {
2566  S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
2568  *Newnullability,
2569  ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2570  != 0))
2572  *Oldnullability,
2573  ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
2574  != 0));
2575  S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
2576  }
2577  } else {
2578  QualType NewT = NewParam->getType();
2579  NewT = S.Context.getAttributedType(
2580  AttributedType::getNullabilityAttrKind(*Oldnullability),
2581  NewT, NewT);
2582  NewParam->setType(NewT);
2583  }
2584  }
2585 }
2586 
2587 namespace {
2588 
2589 /// Used in MergeFunctionDecl to keep track of function parameters in
2590 /// C.
2591 struct GNUCompatibleParamWarning {
2592  ParmVarDecl *OldParm;
2593  ParmVarDecl *NewParm;
2594  QualType PromotedType;
2595 };
2596 
2597 } // end anonymous namespace
2598 
2599 /// getSpecialMember - get the special member enum for a method.
2601  if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
2602  if (Ctor->isDefaultConstructor())
2604 
2605  if (Ctor->isCopyConstructor())
2606  return Sema::CXXCopyConstructor;
2607 
2608  if (Ctor->isMoveConstructor())
2609  return Sema::CXXMoveConstructor;
2610  } else if (isa<CXXDestructorDecl>(MD)) {
2611  return Sema::CXXDestructor;
2612  } else if (MD->isCopyAssignmentOperator()) {
2613  return Sema::CXXCopyAssignment;
2614  } else if (MD->isMoveAssignmentOperator()) {
2615  return Sema::CXXMoveAssignment;
2616  }
2617 
2618  return Sema::CXXInvalid;
2619 }
2620 
2621 // Determine whether the previous declaration was a definition, implicit
2622 // declaration, or a declaration.
2623 template <typename T>
2624 static std::pair<diag::kind, SourceLocation>
2625 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
2626  diag::kind PrevDiag;
2627  SourceLocation OldLocation = Old->getLocation();
2628  if (Old->isThisDeclarationADefinition())
2629  PrevDiag = diag::note_previous_definition;
2630  else if (Old->isImplicit()) {
2631  PrevDiag = diag::note_previous_implicit_declaration;
2632  if (OldLocation.isInvalid())
2633  OldLocation = New->getLocation();
2634  } else
2635  PrevDiag = diag::note_previous_declaration;
2636  return std::make_pair(PrevDiag, OldLocation);
2637 }
2638 
2639 /// canRedefineFunction - checks if a function can be redefined. Currently,
2640 /// only extern inline functions can be redefined, and even then only in
2641 /// GNU89 mode.
2642 static bool canRedefineFunction(const FunctionDecl *FD,
2643  const LangOptions& LangOpts) {
2644  return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
2645  !LangOpts.CPlusPlus &&
2646  FD->isInlineSpecified() &&
2647  FD->getStorageClass() == SC_Extern);
2648 }
2649 
2651  const AttributedType *AT = T->getAs<AttributedType>();
2652  while (AT && !AT->isCallingConv())
2653  AT = AT->getModifiedType()->getAs<AttributedType>();
2654  return AT;
2655 }
2656 
2657 template <typename T>
2658 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
2659  const DeclContext *DC = Old->getDeclContext();
2660  if (DC->isRecord())
2661  return false;
2662 
2663  LanguageLinkage OldLinkage = Old->getLanguageLinkage();
2664  if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
2665  return true;
2666  if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
2667  return true;
2668  return false;
2669 }
2670 
2671 template<typename T> static bool isExternC(T *D) { return D->isExternC(); }
2672 static bool isExternC(VarTemplateDecl *) { return false; }
2673 
2674 /// \brief Check whether a redeclaration of an entity introduced by a
2675 /// using-declaration is valid, given that we know it's not an overload
2676 /// (nor a hidden tag declaration).
2677 template<typename ExpectedDecl>
2679  ExpectedDecl *New) {
2680  // C++11 [basic.scope.declarative]p4:
2681  // Given a set of declarations in a single declarative region, each of
2682  // which specifies the same unqualified name,
2683  // -- they shall all refer to the same entity, or all refer to functions
2684  // and function templates; or
2685  // -- exactly one declaration shall declare a class name or enumeration
2686  // name that is not a typedef name and the other declarations shall all
2687  // refer to the same variable or enumerator, or all refer to functions
2688  // and function templates; in this case the class name or enumeration
2689  // name is hidden (3.3.10).
2690 
2691  // C++11 [namespace.udecl]p14:
2692  // If a function declaration in namespace scope or block scope has the
2693  // same name and the same parameter-type-list as a function introduced
2694  // by a using-declaration, and the declarations do not declare the same
2695  // function, the program is ill-formed.
2696 
2697  auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl());
2698  if (Old &&
2699  !Old->getDeclContext()->getRedeclContext()->Equals(
2700  New->getDeclContext()->getRedeclContext()) &&
2701  !(isExternC(Old) && isExternC(New)))
2702  Old = nullptr;
2703 
2704  if (!Old) {
2705  S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2706  S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
2707  S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2708  return true;
2709  }
2710  return false;
2711 }
2712 
2714  const FunctionDecl *B) {
2715  assert(A->getNumParams() == B->getNumParams());
2716 
2717  auto AttrEq = [](const ParmVarDecl *A, const ParmVarDecl *B) {
2718  const auto *AttrA = A->getAttr<PassObjectSizeAttr>();
2719  const auto *AttrB = B->getAttr<PassObjectSizeAttr>();
2720  if (AttrA == AttrB)
2721  return true;
2722  return AttrA && AttrB && AttrA->getType() == AttrB->getType();
2723  };
2724 
2725  return std::equal(A->param_begin(), A->param_end(), B->param_begin(), AttrEq);
2726 }
2727 
2728 /// MergeFunctionDecl - We just parsed a function 'New' from
2729 /// declarator D which has the same name and scope as a previous
2730 /// declaration 'Old'. Figure out how to resolve this situation,
2731 /// merging decls or emitting diagnostics as appropriate.
2732 ///
2733 /// In C++, New and Old must be declarations that are not
2734 /// overloaded. Use IsOverload to determine whether New and Old are
2735 /// overloaded, and to select the Old declaration that New should be
2736 /// merged with.
2737 ///
2738 /// Returns true if there was an error, false otherwise.
2740  Scope *S, bool MergeTypeWithOld) {
2741  // Verify the old decl was also a function.
2742  FunctionDecl *Old = OldD->getAsFunction();
2743  if (!Old) {
2744  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
2745  if (New->getFriendObjectKind()) {
2746  Diag(New->getLocation(), diag::err_using_decl_friend);
2747  Diag(Shadow->getTargetDecl()->getLocation(),
2748  diag::note_using_decl_target);
2749  Diag(Shadow->getUsingDecl()->getLocation(),
2750  diag::note_using_decl) << 0;
2751  return true;
2752  }
2753 
2754  // Check whether the two declarations might declare the same function.
2755  if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
2756  return true;
2757  OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
2758  } else {
2759  Diag(New->getLocation(), diag::err_redefinition_different_kind)
2760  << New->getDeclName();
2761  Diag(OldD->getLocation(), diag::note_previous_definition);
2762  return true;
2763  }
2764  }
2765 
2766  // If the old declaration is invalid, just give up here.
2767  if (Old->isInvalidDecl())
2768  return true;
2769 
2770  diag::kind PrevDiag;
2771  SourceLocation OldLocation;
2772  std::tie(PrevDiag, OldLocation) =
2774 
2775  // Don't complain about this if we're in GNU89 mode and the old function
2776  // is an extern inline function.
2777  // Don't complain about specializations. They are not supposed to have
2778  // storage classes.
2779  if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
2780  New->getStorageClass() == SC_Static &&
2781  Old->hasExternalFormalLinkage() &&
2783  !canRedefineFunction(Old, getLangOpts())) {
2784  if (getLangOpts().MicrosoftExt) {
2785  Diag(New->getLocation(), diag::ext_static_non_static) << New;
2786  Diag(OldLocation, PrevDiag);
2787  } else {
2788  Diag(New->getLocation(), diag::err_static_non_static) << New;
2789  Diag(OldLocation, PrevDiag);
2790  return true;
2791  }
2792  }
2793 
2794  if (New->hasAttr<InternalLinkageAttr>() &&
2795  !Old->hasAttr<InternalLinkageAttr>()) {
2796  Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
2797  << New->getDeclName();
2798  Diag(Old->getLocation(), diag::note_previous_definition);
2799  New->dropAttr<InternalLinkageAttr>();
2800  }
2801 
2802  // If a function is first declared with a calling convention, but is later
2803  // declared or defined without one, all following decls assume the calling
2804  // convention of the first.
2805  //
2806  // It's OK if a function is first declared without a calling convention,
2807  // but is later declared or defined with the default calling convention.
2808  //
2809  // To test if either decl has an explicit calling convention, we look for
2810  // AttributedType sugar nodes on the type as written. If they are missing or
2811  // were canonicalized away, we assume the calling convention was implicit.
2812  //
2813  // Note also that we DO NOT return at this point, because we still have
2814  // other tests to run.
2815  QualType OldQType = Context.getCanonicalType(Old->getType());
2816  QualType NewQType = Context.getCanonicalType(New->getType());
2817  const FunctionType *OldType = cast<FunctionType>(OldQType);
2818  const FunctionType *NewType = cast<FunctionType>(NewQType);
2819  FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
2820  FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
2821  bool RequiresAdjustment = false;
2822 
2823  if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
2824  FunctionDecl *First = Old->getFirstDecl();
2825  const FunctionType *FT =
2827  FunctionType::ExtInfo FI = FT->getExtInfo();
2828  bool NewCCExplicit = getCallingConvAttributedType(New->getType());
2829  if (!NewCCExplicit) {
2830  // Inherit the CC from the previous declaration if it was specified
2831  // there but not here.
2832  NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
2833  RequiresAdjustment = true;
2834  } else {
2835  // Calling conventions aren't compatible, so complain.
2836  bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
2837  Diag(New->getLocation(), diag::err_cconv_change)
2838  << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
2839  << !FirstCCExplicit
2840  << (!FirstCCExplicit ? "" :
2841  FunctionType::getNameForCallConv(FI.getCC()));
2842 
2843  // Put the note on the first decl, since it is the one that matters.
2844  Diag(First->getLocation(), diag::note_previous_declaration);
2845  return true;
2846  }
2847  }
2848 
2849  // FIXME: diagnose the other way around?
2850  if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
2851  NewTypeInfo = NewTypeInfo.withNoReturn(true);
2852  RequiresAdjustment = true;
2853  }
2854 
2855  // Merge regparm attribute.
2856  if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
2857  OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
2858  if (NewTypeInfo.getHasRegParm()) {
2859  Diag(New->getLocation(), diag::err_regparm_mismatch)
2860  << NewType->getRegParmType()
2861  << OldType->getRegParmType();
2862  Diag(OldLocation, diag::note_previous_declaration);
2863  return true;
2864  }
2865 
2866  NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
2867  RequiresAdjustment = true;
2868  }
2869 
2870  // Merge ns_returns_retained attribute.
2871  if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
2872  if (NewTypeInfo.getProducesResult()) {
2873  Diag(New->getLocation(), diag::err_returns_retained_mismatch);
2874  Diag(OldLocation, diag::note_previous_declaration);
2875  return true;
2876  }
2877 
2878  NewTypeInfo = NewTypeInfo.withProducesResult(true);
2879  RequiresAdjustment = true;
2880  }
2881 
2882  if (RequiresAdjustment) {
2883  const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
2884  AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
2885  New->setType(QualType(AdjustedType, 0));
2886  NewQType = Context.getCanonicalType(New->getType());
2887  NewType = cast<FunctionType>(NewQType);
2888  }
2889 
2890  // If this redeclaration makes the function inline, we may need to add it to
2891  // UndefinedButUsed.
2892  if (!Old->isInlined() && New->isInlined() &&
2893  !New->hasAttr<GNUInlineAttr>() &&
2894  !getLangOpts().GNUInline &&
2895  Old->isUsed(false) &&
2896  !Old->isDefined() && !New->isThisDeclarationADefinition())
2897  UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
2898  SourceLocation()));
2899 
2900  // If this redeclaration makes it newly gnu_inline, we don't want to warn
2901  // about it.
2902  if (New->hasAttr<GNUInlineAttr>() &&
2903  Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
2904  UndefinedButUsed.erase(Old->getCanonicalDecl());
2905  }
2906 
2907  // If pass_object_size params don't match up perfectly, this isn't a valid
2908  // redeclaration.
2909  if (Old->getNumParams() > 0 && Old->getNumParams() == New->getNumParams() &&
2910  !hasIdenticalPassObjectSizeAttrs(Old, New)) {
2911  Diag(New->getLocation(), diag::err_different_pass_object_size_params)
2912  << New->getDeclName();
2913  Diag(OldLocation, PrevDiag) << Old << Old->getType();
2914  return true;
2915  }
2916 
2917  if (getLangOpts().CPlusPlus) {
2918  // (C++98 13.1p2):
2919  // Certain function declarations cannot be overloaded:
2920  // -- Function declarations that differ only in the return type
2921  // cannot be overloaded.
2922 
2923  // Go back to the type source info to compare the declared return types,
2924  // per C++1y [dcl.type.auto]p13:
2925  // Redeclarations or specializations of a function or function template
2926  // with a declared return type that uses a placeholder type shall also
2927  // use that placeholder, not a deduced type.
2928  QualType OldDeclaredReturnType =
2929  (Old->getTypeSourceInfo()
2931  : OldType)->getReturnType();
2932  QualType NewDeclaredReturnType =
2933  (New->getTypeSourceInfo()
2935  : NewType)->getReturnType();
2936  QualType ResQT;
2937  if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
2938  !((NewQType->isDependentType() || OldQType->isDependentType()) &&
2939  New->isLocalExternDecl())) {
2940  if (NewDeclaredReturnType->isObjCObjectPointerType() &&
2941  OldDeclaredReturnType->isObjCObjectPointerType())
2942  ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
2943  if (ResQT.isNull()) {
2944  if (New->isCXXClassMember() && New->isOutOfLine())
2945  Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
2946  << New << New->getReturnTypeSourceRange();
2947  else
2948  Diag(New->getLocation(), diag::err_ovl_diff_return_type)
2949  << New->getReturnTypeSourceRange();
2950  Diag(OldLocation, PrevDiag) << Old << Old->getType()
2951  << Old->getReturnTypeSourceRange();
2952  return true;
2953  }
2954  else
2955  NewQType = ResQT;
2956  }
2957 
2958  QualType OldReturnType = OldType->getReturnType();
2959  QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
2960  if (OldReturnType != NewReturnType) {
2961  // If this function has a deduced return type and has already been
2962  // defined, copy the deduced value from the old declaration.
2963  AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
2964  if (OldAT && OldAT->isDeduced()) {
2965  New->setType(
2966  SubstAutoType(New->getType(),
2968  : OldAT->getDeducedType()));
2969  NewQType = Context.getCanonicalType(
2970  SubstAutoType(NewQType,
2972  : OldAT->getDeducedType()));
2973  }
2974  }
2975 
2976  const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
2977  CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
2978  if (OldMethod && NewMethod) {
2979  // Preserve triviality.
2980  NewMethod->setTrivial(OldMethod->isTrivial());
2981 
2982  // MSVC allows explicit template specialization at class scope:
2983  // 2 CXXMethodDecls referring to the same function will be injected.
2984  // We don't want a redeclaration error.
2985  bool IsClassScopeExplicitSpecialization =
2986  OldMethod->isFunctionTemplateSpecialization() &&
2987  NewMethod->isFunctionTemplateSpecialization();
2988  bool isFriend = NewMethod->getFriendObjectKind();
2989 
2990  if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
2991  !IsClassScopeExplicitSpecialization) {
2992  // -- Member function declarations with the same name and the
2993  // same parameter types cannot be overloaded if any of them
2994  // is a static member function declaration.
2995  if (OldMethod->isStatic() != NewMethod->isStatic()) {
2996  Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
2997  Diag(OldLocation, PrevDiag) << Old << Old->getType();
2998  return true;
2999  }
3000 
3001  // C++ [class.mem]p1:
3002  // [...] A member shall not be declared twice in the
3003  // member-specification, except that a nested class or member
3004  // class template can be declared and then later defined.
3005  if (ActiveTemplateInstantiations.empty()) {
3006  unsigned NewDiag;
3007  if (isa<CXXConstructorDecl>(OldMethod))
3008  NewDiag = diag::err_constructor_redeclared;
3009  else if (isa<CXXDestructorDecl>(NewMethod))
3010  NewDiag = diag::err_destructor_redeclared;
3011  else if (isa<CXXConversionDecl>(NewMethod))
3012  NewDiag = diag::err_conv_function_redeclared;
3013  else
3014  NewDiag = diag::err_member_redeclared;
3015 
3016  Diag(New->getLocation(), NewDiag);
3017  } else {
3018  Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
3019  << New << New->getType();
3020  }
3021  Diag(OldLocation, PrevDiag) << Old << Old->getType();
3022  return true;
3023 
3024  // Complain if this is an explicit declaration of a special
3025  // member that was initially declared implicitly.
3026  //
3027  // As an exception, it's okay to befriend such methods in order
3028  // to permit the implicit constructor/destructor/operator calls.
3029  } else if (OldMethod->isImplicit()) {
3030  if (isFriend) {
3031  NewMethod->setImplicit();
3032  } else {
3033  Diag(NewMethod->getLocation(),
3034  diag::err_definition_of_implicitly_declared_member)
3035  << New << getSpecialMember(OldMethod);
3036  return true;
3037  }
3038  } else if (OldMethod->getFirstDecl()->isExplicitlyDefaulted() && !isFriend) {
3039  Diag(NewMethod->getLocation(),
3040  diag::err_definition_of_explicitly_defaulted_member)
3041  << getSpecialMember(OldMethod);
3042  return true;
3043  }
3044  }
3045 
3046  // C++11 [dcl.attr.noreturn]p1:
3047  // The first declaration of a function shall specify the noreturn
3048  // attribute if any declaration of that function specifies the noreturn
3049  // attribute.
3050  const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
3051  if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
3052  Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
3053  Diag(Old->getFirstDecl()->getLocation(),
3054  diag::note_noreturn_missing_first_decl);
3055  }
3056 
3057  // C++11 [dcl.attr.depend]p2:
3058  // The first declaration of a function shall specify the
3059  // carries_dependency attribute for its declarator-id if any declaration
3060  // of the function specifies the carries_dependency attribute.
3061  const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
3062  if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
3063  Diag(CDA->getLocation(),
3064  diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
3065  Diag(Old->getFirstDecl()->getLocation(),
3066  diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
3067  }
3068 
3069  // (C++98 8.3.5p3):
3070  // All declarations for a function shall agree exactly in both the
3071  // return type and the parameter-type-list.
3072  // We also want to respect all the extended bits except noreturn.
3073 
3074  // noreturn should now match unless the old type info didn't have it.
3075  QualType OldQTypeForComparison = OldQType;
3076  if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
3077  assert(OldQType == QualType(OldType, 0));
3078  const FunctionType *OldTypeForComparison
3079  = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
3080  OldQTypeForComparison = QualType(OldTypeForComparison, 0);
3081  assert(OldQTypeForComparison.isCanonical());
3082  }
3083 
3084  if (haveIncompatibleLanguageLinkages(Old, New)) {
3085  // As a special case, retain the language linkage from previous
3086  // declarations of a friend function as an extension.
3087  //
3088  // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
3089  // and is useful because there's otherwise no way to specify language
3090  // linkage within class scope.
3091  //
3092  // Check cautiously as the friend object kind isn't yet complete.
3093  if (New->getFriendObjectKind() != Decl::FOK_None) {
3094  Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
3095  Diag(OldLocation, PrevDiag);
3096  } else {
3097  Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3098  Diag(OldLocation, PrevDiag);
3099  return true;
3100  }
3101  }
3102 
3103  if (OldQTypeForComparison == NewQType)
3104  return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3105 
3106  if ((NewQType->isDependentType() || OldQType->isDependentType()) &&
3107  New->isLocalExternDecl()) {
3108  // It's OK if we couldn't merge types for a local function declaraton
3109  // if either the old or new type is dependent. We'll merge the types
3110  // when we instantiate the function.
3111  return false;
3112  }
3113 
3114  // Fall through for conflicting redeclarations and redefinitions.
3115  }
3116 
3117  // C: Function types need to be compatible, not identical. This handles
3118  // duplicate function decls like "void f(int); void f(enum X);" properly.
3119  if (!getLangOpts().CPlusPlus &&
3120  Context.typesAreCompatible(OldQType, NewQType)) {
3121  const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
3122  const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
3123  const FunctionProtoType *OldProto = nullptr;
3124  if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
3125  (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
3126  // The old declaration provided a function prototype, but the
3127  // new declaration does not. Merge in the prototype.
3128  assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
3129  SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
3130  NewQType =
3131  Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
3132  OldProto->getExtProtoInfo());
3133  New->setType(NewQType);
3134  New->setHasInheritedPrototype();
3135 
3136  // Synthesize parameters with the same types.
3138  for (const auto &ParamType : OldProto->param_types()) {
3140  SourceLocation(), nullptr,
3141  ParamType, /*TInfo=*/nullptr,
3142  SC_None, nullptr);
3143  Param->setScopeInfo(0, Params.size());
3144  Param->setImplicit();
3145  Params.push_back(Param);
3146  }
3147 
3148  New->setParams(Params);
3149  }
3150 
3151  return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3152  }
3153 
3154  // GNU C permits a K&R definition to follow a prototype declaration
3155  // if the declared types of the parameters in the K&R definition
3156  // match the types in the prototype declaration, even when the
3157  // promoted types of the parameters from the K&R definition differ
3158  // from the types in the prototype. GCC then keeps the types from
3159  // the prototype.
3160  //
3161  // If a variadic prototype is followed by a non-variadic K&R definition,
3162  // the K&R definition becomes variadic. This is sort of an edge case, but
3163  // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3164  // C99 6.9.1p8.
3165  if (!getLangOpts().CPlusPlus &&
3166  Old->hasPrototype() && !New->hasPrototype() &&
3167  New->getType()->getAs<FunctionProtoType>() &&
3168  Old->getNumParams() == New->getNumParams()) {
3169  SmallVector<QualType, 16> ArgTypes;
3171  const FunctionProtoType *OldProto
3172  = Old->getType()->getAs<FunctionProtoType>();
3173  const FunctionProtoType *NewProto
3174  = New->getType()->getAs<FunctionProtoType>();
3175 
3176  // Determine whether this is the GNU C extension.
3177  QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3178  NewProto->getReturnType());
3179  bool LooseCompatible = !MergedReturn.isNull();
3180  for (unsigned Idx = 0, End = Old->getNumParams();
3181  LooseCompatible && Idx != End; ++Idx) {
3182  ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3183  ParmVarDecl *NewParm = New->getParamDecl(Idx);
3184  if (Context.typesAreCompatible(OldParm->getType(),
3185  NewProto->getParamType(Idx))) {
3186  ArgTypes.push_back(NewParm->getType());
3187  } else if (Context.typesAreCompatible(OldParm->getType(),
3188  NewParm->getType(),
3189  /*CompareUnqualified=*/true)) {
3190  GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3191  NewProto->getParamType(Idx) };
3192  Warnings.push_back(Warn);
3193  ArgTypes.push_back(NewParm->getType());
3194  } else
3195  LooseCompatible = false;
3196  }
3197 
3198  if (LooseCompatible) {
3199  for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3200  Diag(Warnings[Warn].NewParm->getLocation(),
3201  diag::ext_param_promoted_not_compatible_with_prototype)
3202  << Warnings[Warn].PromotedType
3203  << Warnings[Warn].OldParm->getType();
3204  if (Warnings[Warn].OldParm->getLocation().isValid())
3205  Diag(Warnings[Warn].OldParm->getLocation(),
3206  diag::note_previous_declaration);
3207  }
3208 
3209  if (MergeTypeWithOld)
3210  New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3211  OldProto->getExtProtoInfo()));
3212  return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3213  }
3214 
3215  // Fall through to diagnose conflicting types.
3216  }
3217 
3218  // A function that has already been declared has been redeclared or
3219  // defined with a different type; show an appropriate diagnostic.
3220 
3221  // If the previous declaration was an implicitly-generated builtin
3222  // declaration, then at the very least we should use a specialized note.
3223  unsigned BuiltinID;
3224  if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3225  // If it's actually a library-defined builtin function like 'malloc'
3226  // or 'printf', just warn about the incompatible redeclaration.
3227  if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
3228  Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
3229  Diag(OldLocation, diag::note_previous_builtin_declaration)
3230  << Old << Old->getType();
3231 
3232  // If this is a global redeclaration, just forget hereafter
3233  // about the "builtin-ness" of the function.
3234  //
3235  // Doing this for local extern declarations is problematic. If
3236  // the builtin declaration remains visible, a second invalid
3237  // local declaration will produce a hard error; if it doesn't
3238  // remain visible, a single bogus local redeclaration (which is
3239  // actually only a warning) could break all the downstream code.
3240  if (!New->getLexicalDeclContext()->isFunctionOrMethod())
3241  New->getIdentifier()->revertBuiltin();
3242 
3243  return false;
3244  }
3245 
3246  PrevDiag = diag::note_previous_builtin_declaration;
3247  }
3248 
3249  Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
3250  Diag(OldLocation, PrevDiag) << Old << Old->getType();
3251  return true;
3252 }
3253 
3254 /// \brief Completes the merge of two function declarations that are
3255 /// known to be compatible.
3256 ///
3257 /// This routine handles the merging of attributes and other
3258 /// properties of function declarations from the old declaration to
3259 /// the new declaration, once we know that New is in fact a
3260 /// redeclaration of Old.
3261 ///
3262 /// \returns false
3264  Scope *S, bool MergeTypeWithOld) {
3265  // Merge the attributes
3266  mergeDeclAttributes(New, Old);
3267 
3268  // Merge "pure" flag.
3269  if (Old->isPure())
3270  New->setPure();
3271 
3272  // Merge "used" flag.
3273  if (Old->getMostRecentDecl()->isUsed(false))
3274  New->setIsUsed();
3275 
3276  // Merge attributes from the parameters. These can mismatch with K&R
3277  // declarations.
3278  if (New->getNumParams() == Old->getNumParams())
3279  for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3280  ParmVarDecl *NewParam = New->getParamDecl(i);
3281  ParmVarDecl *OldParam = Old->getParamDecl(i);
3282  mergeParamDeclAttributes(NewParam, OldParam, *this);
3283  mergeParamDeclTypes(NewParam, OldParam, *this);
3284  }
3285 
3286  if (getLangOpts().CPlusPlus)
3287  return MergeCXXFunctionDecl(New, Old, S);
3288 
3289  // Merge the function types so the we get the composite types for the return
3290  // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3291  // was visible.
3292  QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
3293  if (!Merged.isNull() && MergeTypeWithOld)
3294  New->setType(Merged);
3295 
3296  return false;
3297 }
3298 
3300  ObjCMethodDecl *oldMethod) {
3301  // Merge the attributes, including deprecated/unavailable
3302  AvailabilityMergeKind MergeKind =
3303  isa<ObjCProtocolDecl>(oldMethod->getDeclContext())
3304  ? AMK_ProtocolImplementation
3305  : isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3306  : AMK_Override;
3307 
3308  mergeDeclAttributes(newMethod, oldMethod, MergeKind);
3309 
3310  // Merge attributes from the parameters.
3312  oe = oldMethod->param_end();
3314  ni = newMethod->param_begin(), ne = newMethod->param_end();
3315  ni != ne && oi != oe; ++ni, ++oi)
3316  mergeParamDeclAttributes(*ni, *oi, *this);
3317 
3318  CheckObjCMethodOverride(newMethod, oldMethod);
3319 }
3320 
3321 static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl* Old) {
3322  assert(!S.Context.hasSameType(New->getType(), Old->getType()));
3323 
3324  S.Diag(New->getLocation(), New->isThisDeclarationADefinition()
3325  ? diag::err_redefinition_different_type
3326  : diag::err_redeclaration_different_type)
3327  << New->getDeclName() << New->getType() << Old->getType();
3328 
3329  diag::kind PrevDiag;
3330  SourceLocation OldLocation;
3331  std::tie(PrevDiag, OldLocation)
3333  S.Diag(OldLocation, PrevDiag);
3334  New->setInvalidDecl();
3335 }
3336 
3337 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3338 /// scope as a previous declaration 'Old'. Figure out how to merge their types,
3339 /// emitting diagnostics as appropriate.
3340 ///
3341 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3342 /// to here in AddInitializerToDecl. We can't check them before the initializer
3343 /// is attached.
3345  bool MergeTypeWithOld) {
3346  if (New->isInvalidDecl() || Old->isInvalidDecl())
3347  return;
3348 
3349  QualType MergedT;
3350  if (getLangOpts().CPlusPlus) {
3351  if (New->getType()->isUndeducedType()) {
3352  // We don't know what the new type is until the initializer is attached.
3353  return;
3354  } else if (Context.hasSameType(New->getType(), Old->getType())) {
3355  // These could still be something that needs exception specs checked.
3356  return MergeVarDeclExceptionSpecs(New, Old);
3357  }
3358  // C++ [basic.link]p10:
3359  // [...] the types specified by all declarations referring to a given
3360  // object or function shall be identical, except that declarations for an
3361  // array object can specify array types that differ by the presence or
3362  // absence of a major array bound (8.3.4).
3363  else if (Old->getType()->isArrayType() && New->getType()->isArrayType()) {
3364  const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3365  const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3366 
3367  // We are merging a variable declaration New into Old. If it has an array
3368  // bound, and that bound differs from Old's bound, we should diagnose the
3369  // mismatch.
3370  if (!NewArray->isIncompleteArrayType()) {
3371  for (VarDecl *PrevVD = Old->getMostRecentDecl(); PrevVD;
3372  PrevVD = PrevVD->getPreviousDecl()) {
3373  const ArrayType *PrevVDTy = Context.getAsArrayType(PrevVD->getType());
3374  if (PrevVDTy->isIncompleteArrayType())
3375  continue;
3376 
3377  if (!Context.hasSameType(NewArray, PrevVDTy))
3378  return diagnoseVarDeclTypeMismatch(*this, New, PrevVD);
3379  }
3380  }
3381 
3382  if (OldArray->isIncompleteArrayType() && NewArray->isArrayType()) {
3383  if (Context.hasSameType(OldArray->getElementType(),
3384  NewArray->getElementType()))
3385  MergedT = New->getType();
3386  }
3387  // FIXME: Check visibility. New is hidden but has a complete type. If New
3388  // has no array bound, it should not inherit one from Old, if Old is not
3389  // visible.
3390  else if (OldArray->isArrayType() && NewArray->isIncompleteArrayType()) {
3391  if (Context.hasSameType(OldArray->getElementType(),
3392  NewArray->getElementType()))
3393  MergedT = Old->getType();
3394  }
3395  }
3396  else if (New->getType()->isObjCObjectPointerType() &&
3397  Old->getType()->isObjCObjectPointerType()) {
3398  MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3399  Old->getType());
3400  }
3401  } else {
3402  // C 6.2.7p2:
3403  // All declarations that refer to the same object or function shall have
3404  // compatible type.
3405  MergedT = Context.mergeTypes(New->getType(), Old->getType());
3406  }
3407  if (MergedT.isNull()) {
3408  // It's OK if we couldn't merge types if either type is dependent, for a
3409  // block-scope variable. In other cases (static data members of class
3410  // templates, variable templates, ...), we require the types to be
3411  // equivalent.
3412  // FIXME: The C++ standard doesn't say anything about this.
3413  if ((New->getType()->isDependentType() ||
3414  Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3415  // If the old type was dependent, we can't merge with it, so the new type
3416  // becomes dependent for now. We'll reproduce the original type when we
3417  // instantiate the TypeSourceInfo for the variable.
3418  if (!New->getType()->isDependentType() && MergeTypeWithOld)
3419  New->setType(Context.DependentTy);
3420  return;
3421  }
3422  return diagnoseVarDeclTypeMismatch(*this, New, Old);
3423  }
3424 
3425  // Don't actually update the type on the new declaration if the old
3426  // declaration was an extern declaration in a different scope.
3427  if (MergeTypeWithOld)
3428  New->setType(MergedT);
3429 }
3430 
3431 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3433  // C11 6.2.7p4:
3434  // For an identifier with internal or external linkage declared
3435  // in a scope in which a prior declaration of that identifier is
3436  // visible, if the prior declaration specifies internal or
3437  // external linkage, the type of the identifier at the later
3438  // declaration becomes the composite type.
3439  //
3440  // If the variable isn't visible, we do not merge with its type.
3441  if (Previous.isShadowed())
3442  return false;
3443 
3444  if (S.getLangOpts().CPlusPlus) {
3445  // C++11 [dcl.array]p3:
3446  // If there is a preceding declaration of the entity in the same
3447  // scope in which the bound was specified, an omitted array bound
3448  // is taken to be the same as in that earlier declaration.
3449  return NewVD->isPreviousDeclInSameBlockScope() ||
3450  (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3451  !NewVD->getLexicalDeclContext()->isFunctionOrMethod());
3452  } else {
3453  // If the old declaration was function-local, don't merge with its
3454  // type unless we're in the same function.
3455  return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
3456  OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
3457  }
3458 }
3459 
3460 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
3461 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
3462 /// situation, merging decls or emitting diagnostics as appropriate.
3463 ///
3464 /// Tentative definition rules (C99 6.9.2p2) are checked by
3465 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
3466 /// definitions here, since the initializer hasn't been attached.
3467 ///
3469  // If the new decl is already invalid, don't do any other checking.
3470  if (New->isInvalidDecl())
3471  return;
3472 
3473  if (!shouldLinkPossiblyHiddenDecl(Previous, New))
3474  return;
3475 
3476  VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
3477 
3478  // Verify the old decl was also a variable or variable template.
3479  VarDecl *Old = nullptr;
3480  VarTemplateDecl *OldTemplate = nullptr;
3481  if (Previous.isSingleResult()) {
3482  if (NewTemplate) {
3483  OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
3484  Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
3485 
3486  if (auto *Shadow =
3487  dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3488  if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate))
3489  return New->setInvalidDecl();
3490  } else {
3491  Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
3492 
3493  if (auto *Shadow =
3494  dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3495  if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New))
3496  return New->setInvalidDecl();
3497  }
3498  }
3499  if (!Old) {
3500  Diag(New->getLocation(), diag::err_redefinition_different_kind)
3501  << New->getDeclName();
3502  Diag(Previous.getRepresentativeDecl()->getLocation(),
3503  diag::note_previous_definition);
3504  return New->setInvalidDecl();
3505  }
3506 
3507  // Ensure the template parameters are compatible.
3508  if (NewTemplate &&
3509  !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3510  OldTemplate->getTemplateParameters(),
3511  /*Complain=*/true, TPL_TemplateMatch))
3512  return New->setInvalidDecl();
3513 
3514  // C++ [class.mem]p1:
3515  // A member shall not be declared twice in the member-specification [...]
3516  //
3517  // Here, we need only consider static data members.
3518  if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3519  Diag(New->getLocation(), diag::err_duplicate_member)
3520  << New->getIdentifier();
3521  Diag(Old->getLocation(), diag::note_previous_declaration);
3522  New->setInvalidDecl();
3523  }
3524 
3525  mergeDeclAttributes(New, Old);
3526  // Warn if an already-declared variable is made a weak_import in a subsequent
3527  // declaration
3528  if (New->hasAttr<WeakImportAttr>() &&
3529  Old->getStorageClass() == SC_None &&
3530  !Old->hasAttr<WeakImportAttr>()) {
3531  Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3532  Diag(Old->getLocation(), diag::note_previous_definition);
3533  // Remove weak_import attribute on new declaration.
3534  New->dropAttr<WeakImportAttr>();
3535  }
3536 
3537  if (New->hasAttr<InternalLinkageAttr>() &&
3538  !Old->hasAttr<InternalLinkageAttr>()) {
3539  Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
3540  << New->getDeclName();
3541  Diag(Old->getLocation(), diag::note_previous_definition);
3542  New->dropAttr<InternalLinkageAttr>();
3543  }
3544 
3545  // Merge the types.
3546  VarDecl *MostRecent = Old->getMostRecentDecl();
3547  if (MostRecent != Old) {
3548  MergeVarDeclTypes(New, MostRecent,
3549  mergeTypeWithPrevious(*this, New, MostRecent, Previous));
3550  if (New->isInvalidDecl())
3551  return;
3552  }
3553 
3554  MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
3555  if (New->isInvalidDecl())
3556  return;
3557 
3558  diag::kind PrevDiag;
3559  SourceLocation OldLocation;
3560  std::tie(PrevDiag, OldLocation) =
3562 
3563  // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
3564  if (New->getStorageClass() == SC_Static &&
3565  !New->isStaticDataMember() &&
3566  Old->hasExternalFormalLinkage()) {
3567  if (getLangOpts().MicrosoftExt) {
3568  Diag(New->getLocation(), diag::ext_static_non_static)
3569  << New->getDeclName();
3570  Diag(OldLocation, PrevDiag);
3571  } else {
3572  Diag(New->getLocation(), diag::err_static_non_static)
3573  << New->getDeclName();
3574  Diag(OldLocation, PrevDiag);
3575  return New->setInvalidDecl();
3576  }
3577  }
3578  // C99 6.2.2p4:
3579  // For an identifier declared with the storage-class specifier
3580  // extern in a scope in which a prior declaration of that
3581  // identifier is visible,23) if the prior declaration specifies
3582  // internal or external linkage, the linkage of the identifier at
3583  // the later declaration is the same as the linkage specified at
3584  // the prior declaration. If no prior declaration is visible, or
3585  // if the prior declaration specifies no linkage, then the
3586  // identifier has external linkage.
3587  if (New->hasExternalStorage() && Old->hasLinkage())
3588  /* Okay */;
3589  else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
3590  !New->isStaticDataMember() &&
3592  Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
3593  Diag(OldLocation, PrevDiag);
3594  return New->setInvalidDecl();
3595  }
3596 
3597  // Check if extern is followed by non-extern and vice-versa.
3598  if (New->hasExternalStorage() &&
3599  !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
3600  Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
3601  Diag(OldLocation, PrevDiag);
3602  return New->setInvalidDecl();
3603  }
3604  if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
3605  !New->hasExternalStorage()) {
3606  Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
3607  Diag(OldLocation, PrevDiag);
3608  return New->setInvalidDecl();
3609  }
3610 
3611  // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
3612 
3613  // FIXME: The test for external storage here seems wrong? We still
3614  // need to check for mismatches.
3615  if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
3616  // Don't complain about out-of-line definitions of static members.
3617  !(Old->getLexicalDeclContext()->isRecord() &&
3618  !New->getLexicalDeclContext()->isRecord())) {
3619  Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
3620  Diag(OldLocation, PrevDiag);
3621  return New->setInvalidDecl();
3622  }
3623 
3624  if (New->isInline() && !Old->getMostRecentDecl()->isInline()) {
3625  if (VarDecl *Def = Old->getDefinition()) {
3626  // C++1z [dcl.fcn.spec]p4:
3627  // If the definition of a variable appears in a translation unit before
3628  // its first declaration as inline, the program is ill-formed.
3629  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
3630  Diag(Def->getLocation(), diag::note_previous_definition);
3631  }
3632  }
3633 
3634  // If this redeclaration makes the function inline, we may need to add it to
3635  // UndefinedButUsed.
3636  if (!Old->isInline() && New->isInline() && Old->isUsed(false) &&
3637  !Old->getDefinition() && !New->isThisDeclarationADefinition())
3638  UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
3639  SourceLocation()));
3640 
3641  if (New->getTLSKind() != Old->getTLSKind()) {
3642  if (!Old->getTLSKind()) {
3643  Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
3644  Diag(OldLocation, PrevDiag);
3645  } else if (!New->getTLSKind()) {
3646  Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
3647  Diag(OldLocation, PrevDiag);
3648  } else {
3649  // Do not allow redeclaration to change the variable between requiring
3650  // static and dynamic initialization.
3651  // FIXME: GCC allows this, but uses the TLS keyword on the first
3652  // declaration to determine the kind. Do we need to be compatible here?
3653  Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3654  << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
3655  Diag(OldLocation, PrevDiag);
3656  }
3657  }
3658 
3659  // C++ doesn't have tentative definitions, so go right ahead and check here.
3660  VarDecl *Def;
3661  if (getLangOpts().CPlusPlus &&
3663  (Def = Old->getDefinition())) {
3664  NamedDecl *Hidden = nullptr;
3665  if (!hasVisibleDefinition(Def, &Hidden) &&
3666  (New->getFormalLinkage() == InternalLinkage ||
3667  New->getDescribedVarTemplate() ||
3669  New->getDeclContext()->isDependentContext())) {
3670  // The previous definition is hidden, and multiple definitions are
3671  // permitted (in separate TUs). Form another definition of it.
3672  } else if (Old->isStaticDataMember() &&
3673  Old->getCanonicalDecl()->isInline() &&
3674  Old->getCanonicalDecl()->isConstexpr()) {
3675  // This definition won't be a definition any more once it's been merged.
3676  Diag(New->getLocation(),
3677  diag::warn_deprecated_redundant_constexpr_static_def);
3678  } else {
3679  Diag(New->getLocation(), diag::err_redefinition) << New;
3680  Diag(Def->getLocation(), diag::note_previous_definition);
3681  New->setInvalidDecl();
3682  return;
3683  }
3684  }
3685 
3686  if (haveIncompatibleLanguageLinkages(Old, New)) {
3687  Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3688  Diag(OldLocation, PrevDiag);
3689  New->setInvalidDecl();
3690  return;
3691  }
3692 
3693  // Merge "used" flag.
3694  if (Old->getMostRecentDecl()->isUsed(false))
3695  New->setIsUsed();
3696 
3697  // Keep a chain of previous declarations.
3698  New->setPreviousDecl(Old);
3699  if (NewTemplate)
3700  NewTemplate->setPreviousDecl(OldTemplate);
3701 
3702  // Inherit access appropriately.
3703  New->setAccess(Old->getAccess());
3704  if (NewTemplate)
3705  NewTemplate->setAccess(New->getAccess());
3706 
3707  if (Old->isInline())
3708  New->setImplicitlyInline();
3709 }
3710 
3711 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3712 /// no declarator (e.g. "struct foo;") is parsed.
3713 Decl *
3715  RecordDecl *&AnonRecord) {
3716  return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg(), false,
3717  AnonRecord);
3718 }
3719 
3720 // The MS ABI changed between VS2013 and VS2015 with regard to numbers used to
3721 // disambiguate entities defined in different scopes.
3722 // While the VS2015 ABI fixes potential miscompiles, it is also breaks
3723 // compatibility.
3724 // We will pick our mangling number depending on which version of MSVC is being
3725 // targeted.
3726 static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) {
3728  ? S->getMSCurManglingNumber()
3729  : S->getMSLastManglingNumber();
3730 }
3731 
3732 void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) {
3733  if (!Context.getLangOpts().CPlusPlus)
3734  return;
3735 
3736  if (isa<CXXRecordDecl>(Tag->getParent())) {
3737  // If this tag is the direct child of a class, number it if
3738  // it is anonymous.
3739  if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
3740  return;
3741  MangleNumberingContext &MCtx =
3744  Tag, MCtx.getManglingNumber(
3745  Tag, getMSManglingNumber(getLangOpts(), TagScope)));
3746  return;
3747  }
3748 
3749  // If this tag isn't a direct child of a class, number it if it is local.
3750  Decl *ManglingContextDecl;
3751  if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
3752  Tag->getDeclContext(), ManglingContextDecl)) {
3754  Tag, MCtx->getManglingNumber(
3755  Tag, getMSManglingNumber(getLangOpts(), TagScope)));
3756  }
3757 }
3758 
3760  TypedefNameDecl *NewTD) {
3761  if (TagFromDeclSpec->isInvalidDecl())
3762  return;
3763 
3764  // Do nothing if the tag already has a name for linkage purposes.
3765  if (TagFromDeclSpec->hasNameForLinkage())
3766  return;
3767 
3768  // A well-formed anonymous tag must always be a TUK_Definition.
3769  assert(TagFromDeclSpec->isThisDeclarationADefinition());
3770 
3771  // The type must match the tag exactly; no qualifiers allowed.
3772  if (!Context.hasSameType(NewTD->getUnderlyingType(),
3773  Context.getTagDeclType(TagFromDeclSpec))) {
3774  if (getLangOpts().CPlusPlus)
3775  Context.addTypedefNameForUnnamedTagDecl(TagFromDeclSpec, NewTD);
3776  return;
3777  }
3778 
3779  // If we've already computed linkage for the anonymous tag, then
3780  // adding a typedef name for the anonymous decl can change that
3781  // linkage, which might be a serious problem. Diagnose this as
3782  // unsupported and ignore the typedef name. TODO: we should
3783  // pursue this as a language defect and establish a formal rule
3784  // for how to handle it.
3785  if (TagFromDeclSpec->hasLinkageBeenComputed()) {
3786  Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage);
3787 
3788  SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart();
3789  tagLoc = getLocForEndOfToken(tagLoc);
3790 
3791  llvm::SmallString<40> textToInsert;
3792  textToInsert += ' ';
3793  textToInsert += NewTD->getIdentifier()->getName();
3794  Diag(tagLoc, diag::note_typedef_changes_linkage)
3795  << FixItHint::CreateInsertion(tagLoc, textToInsert);
3796  return;
3797  }
3798 
3799  // Otherwise, set this is the anon-decl typedef for the tag.
3800  TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
3801 }
3802 
3804  switch (T) {
3805  case DeclSpec::TST_class:
3806  return 0;
3807  case DeclSpec::TST_struct:
3808  return 1;
3810  return 2;
3811  case DeclSpec::TST_union:
3812  return 3;
3813  case DeclSpec::TST_enum:
3814  return 4;
3815  default:
3816  llvm_unreachable("unexpected type specifier");
3817  }
3818 }
3819 
3820 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3821 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template
3822 /// parameters to cope with template friend declarations.
3823 Decl *
3825  MultiTemplateParamsArg TemplateParams,
3826  bool IsExplicitInstantiation,
3827  RecordDecl *&AnonRecord) {
3828  Decl *TagD = nullptr;
3829  TagDecl *Tag = nullptr;
3830  if (DS.getTypeSpecType() == DeclSpec::TST_class ||
3835  TagD = DS.getRepAsDecl();
3836 
3837  if (!TagD) // We probably had an error
3838  return nullptr;
3839 
3840  // Note that the above type specs guarantee that the
3841  // type rep is a Decl, whereas in many of the others
3842  // it's a Type.
3843  if (isa<TagDecl>(TagD))
3844  Tag = cast<TagDecl>(TagD);
3845  else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
3846  Tag = CTD->getTemplatedDecl();
3847  }
3848 
3849  if (Tag) {
3850  handleTagNumbering(Tag, S);
3851  Tag->setFreeStanding();
3852  if (Tag->isInvalidDecl())
3853  return Tag;
3854  }
3855 
3856  if (unsigned TypeQuals = DS.getTypeQualifiers()) {
3857  // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
3858  // or incomplete types shall not be restrict-qualified."
3859  if (TypeQuals & DeclSpec::TQ_restrict)
3860  Diag(DS.getRestrictSpecLoc(),
3861  diag::err_typecheck_invalid_restrict_not_pointer_noarg)
3862  << DS.getSourceRange();
3863  }
3864 
3865  if (DS.isInlineSpecified())
3866  Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
3867  << getLangOpts().CPlusPlus1z;
3868 
3869  if (DS.isConstexprSpecified()) {
3870  // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
3871  // and definitions of functions and variables.
3872  if (Tag)
3873  Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
3875  else
3876  Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
3877  // Don't emit warnings after this error.
3878  return TagD;
3879  }
3880 
3881  if (DS.isConceptSpecified()) {
3882  // C++ Concepts TS [dcl.spec.concept]p1: A concept definition refers to
3883  // either a function concept and its definition or a variable concept and
3884  // its initializer.
3885  Diag(DS.getConceptSpecLoc(), diag::err_concept_wrong_decl_kind);
3886  return TagD;
3887  }
3888 
3889  DiagnoseFunctionSpecifiers(DS);
3890 
3891  if (DS.isFriendSpecified()) {
3892  // If we're dealing with a decl but not a TagDecl, assume that
3893  // whatever routines created it handled the friendship aspect.
3894  if (TagD && !Tag)
3895  return nullptr;
3896  return ActOnFriendTypeDecl(S, DS, TemplateParams);
3897  }
3898 
3899  const CXXScopeSpec &SS = DS.getTypeSpecScope();
3900  bool IsExplicitSpecialization =
3901  !TemplateParams.empty() && TemplateParams.back()->size() == 0;
3902  if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
3903  !IsExplicitInstantiation && !IsExplicitSpecialization &&
3904  !isa<ClassTemplatePartialSpecializationDecl>(Tag)) {
3905  // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
3906  // nested-name-specifier unless it is an explicit instantiation
3907  // or an explicit specialization.
3908  //
3909  // FIXME: We allow class template partial specializations here too, per the
3910  // obvious intent of DR1819.
3911  //
3912  // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
3913  Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
3915  return nullptr;
3916  }
3917 
3918  // Track whether this decl-specifier declares anything.
3919  bool DeclaresAnything = true;
3920 
3921  // Handle anonymous struct definitions.
3922  if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
3923  if (!Record->getDeclName() && Record->isCompleteDefinition() &&
3925  if (getLangOpts().CPlusPlus ||
3926  Record->getDeclContext()->isRecord()) {
3927  // If CurContext is a DeclContext that can contain statements,
3928  // RecursiveASTVisitor won't visit the decls that
3929  // BuildAnonymousStructOrUnion() will put into CurContext.
3930  // Also store them here so that they can be part of the
3931  // DeclStmt that gets created in this case.
3932  // FIXME: Also return the IndirectFieldDecls created by
3933  // BuildAnonymousStructOr union, for the same reason?
3934  if (CurContext->isFunctionOrMethod())
3935  AnonRecord = Record;
3936  return BuildAnonymousStructOrUnion(S, DS, AS, Record,
3938  }
3939 
3940  DeclaresAnything = false;
3941  }
3942  }
3943 
3944  // C11 6.7.2.1p2:
3945  // A struct-declaration that does not declare an anonymous structure or
3946  // anonymous union shall contain a struct-declarator-list.
3947  //
3948  // This rule also existed in C89 and C99; the grammar for struct-declaration
3949  // did not permit a struct-declaration without a struct-declarator-list.
3950  if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
3952  // Check for Microsoft C extension: anonymous struct/union member.
3953  // Handle 2 kinds of anonymous struct/union:
3954  // struct STRUCT;
3955  // union UNION;
3956  // and
3957  // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
3958  // UNION_TYPE; <- where UNION_TYPE is a typedef union.
3959  if ((Tag && Tag->getDeclName()) ||
3961  RecordDecl *Record = nullptr;
3962  if (Tag)
3963  Record = dyn_cast<RecordDecl>(Tag);
3964  else if (const RecordType *RT =
3966  Record = RT->getDecl();
3967  else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
3968  Record = UT->getDecl();
3969 
3970  if (Record && getLangOpts().MicrosoftExt) {
3971  Diag(DS.getLocStart(), diag::ext_ms_anonymous_record)
3972  << Record->isUnion() << DS.getSourceRange();
3973  return BuildMicrosoftCAnonymousStruct(S, DS, Record);
3974  }
3975 
3976  DeclaresAnything = false;
3977  }
3978  }
3979 
3980  // Skip all the checks below if we have a type error.
3981  if (DS.getTypeSpecType() == DeclSpec::TST_error ||
3982  (TagD && TagD->isInvalidDecl()))
3983  return TagD;
3984 
3985  if (getLangOpts().CPlusPlus &&
3987  if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
3988  if (Enum->enumerator_begin() == Enum->enumerator_end() &&
3989  !Enum->getIdentifier() && !Enum->isInvalidDecl())
3990  DeclaresAnything = false;
3991 
3992  if (!DS.isMissingDeclaratorOk()) {
3993  // Customize diagnostic for a typedef missing a name.
3995  Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
3996  << DS.getSourceRange();
3997  else
3998  DeclaresAnything = false;
3999  }
4000 
4001  if (DS.isModulePrivateSpecified() &&
4002  Tag && Tag->getDeclContext()->isFunctionOrMethod())
4003  Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
4004  << Tag->getTagKind()
4006 
4007  ActOnDocumentableDecl(TagD);
4008 
4009  // C 6.7/2:
4010  // A declaration [...] shall declare at least a declarator [...], a tag,
4011  // or the members of an enumeration.
4012  // C++ [dcl.dcl]p3:
4013  // [If there are no declarators], and except for the declaration of an
4014  // unnamed bit-field, the decl-specifier-seq shall introduce one or more
4015  // names into the program, or shall redeclare a name introduced by a
4016  // previous declaration.
4017  if (!DeclaresAnything) {
4018  // In C, we allow this as a (popular) extension / bug. Don't bother
4019  // producing further diagnostics for redundant qualifiers after this.
4020  Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
4021  return TagD;
4022  }
4023 
4024  // C++ [dcl.stc]p1:
4025  // If a storage-class-specifier appears in a decl-specifier-seq, [...] the
4026  // init-declarator-list of the declaration shall not be empty.
4027  // C++ [dcl.fct.spec]p1:
4028  // If a cv-qualifier appears in a decl-specifier-seq, the
4029  // init-declarator-list of the declaration shall not be empty.
4030  //
4031  // Spurious qualifiers here appear to be valid in C.
4032  unsigned DiagID = diag::warn_standalone_specifier;
4033  if (getLangOpts().CPlusPlus)
4034  DiagID = diag::ext_standalone_specifier;
4035 
4036  // Note that a linkage-specification sets a storage class, but
4037  // 'extern "C" struct foo;' is actually valid and not theoretically
4038  // useless.
4039  if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
4040  if (SCS == DeclSpec::SCS_mutable)
4041  // Since mutable is not a viable storage class specifier in C, there is
4042  // no reason to treat it as an extension. Instead, diagnose as an error.
4043  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
4044  else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
4045  Diag(DS.getStorageClassSpecLoc(), DiagID)
4047  }
4048 
4049  if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
4050  Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
4051  << DeclSpec::getSpecifierName(TSCS);
4052  if (DS.getTypeQualifiers()) {
4054  Diag(DS.getConstSpecLoc(), DiagID) << "const";
4056  Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
4057  // Restrict is covered above.
4059  Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
4061  Diag(DS.getUnalignedSpecLoc(), DiagID) << "__unaligned";
4062  }
4063 
4064  // Warn about ignored type attributes, for example:
4065  // __attribute__((aligned)) struct A;
4066  // Attributes should be placed after tag to apply to type declaration.
4067  if (!DS.getAttributes().empty()) {
4068  DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
4069  if (TypeSpecType == DeclSpec::TST_class ||
4070  TypeSpecType == DeclSpec::TST_struct ||
4071  TypeSpecType == DeclSpec::TST_interface ||
4072  TypeSpecType == DeclSpec::TST_union ||
4073  TypeSpecType == DeclSpec::TST_enum) {
4074  for (AttributeList* attrs = DS.getAttributes().getList(); attrs;
4075  attrs = attrs->getNext())
4076  Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
4077  << attrs->getName() << GetDiagnosticTypeSpecifierID(TypeSpecType);
4078  }
4079  }
4080 
4081  return TagD;
4082 }
4083 
4084 /// We are trying to inject an anonymous member into the given scope;
4085 /// check if there's an existing declaration that can't be overloaded.
4086 ///
4087 /// \return true if this is a forbidden redeclaration
4088 static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
4089  Scope *S,
4090  DeclContext *Owner,
4092  SourceLocation NameLoc,
4093  bool IsUnion) {
4094  LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
4096  if (!SemaRef.LookupName(R, S)) return false;
4097 
4098  // Pick a representative declaration.
4100  assert(PrevDecl && "Expected a non-null Decl");
4101 
4102  if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
4103  return false;
4104 
4105  SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl)
4106  << IsUnion << Name;
4107  SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
4108 
4109  return true;
4110 }
4111 
4112 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
4113 /// anonymous struct or union AnonRecord into the owning context Owner
4114 /// and scope S. This routine will be invoked just after we realize
4115 /// that an unnamed union or struct is actually an anonymous union or
4116 /// struct, e.g.,
4117 ///
4118 /// @code
4119 /// union {
4120 /// int i;
4121 /// float f;
4122 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
4123 /// // f into the surrounding scope.x
4124 /// @endcode
4125 ///
4126 /// This routine is recursive, injecting the names of nested anonymous
4127 /// structs/unions into the owning context and scope as well.
4128 static bool
4130  RecordDecl *AnonRecord, AccessSpecifier AS,
4131  SmallVectorImpl<NamedDecl *> &Chaining) {
4132  bool Invalid = false;
4133 
4134  // Look every FieldDecl and IndirectFieldDecl with a name.
4135  for (auto *D : AnonRecord->decls()) {
4136  if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
4137  cast<NamedDecl>(D)->getDeclName()) {
4138  ValueDecl *VD = cast<ValueDecl>(D);
4139  if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
4140  VD->getLocation(),
4141  AnonRecord->isUnion())) {
4142  // C++ [class.union]p2:
4143  // The names of the members of an anonymous union shall be
4144  // distinct from the names of any other entity in the
4145  // scope in which the anonymous union is declared.
4146  Invalid = true;
4147  } else {
4148  // C++ [class.union]p2:
4149  // For the purpose of name lookup, after the anonymous union
4150  // definition, the members of the anonymous union are
4151  // considered to have been defined in the scope in which the
4152  // anonymous union is declared.
4153  unsigned OldChainingSize = Chaining.size();
4154  if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
4155  Chaining.append(IF->chain_begin(), IF->chain_end());
4156  else
4157  Chaining.push_back(VD);
4158 
4159  assert(Chaining.size() >= 2);
4160  NamedDecl **NamedChain =
4161  new (SemaRef.Context)NamedDecl*[Chaining.size()];
4162  for (unsigned i = 0; i < Chaining.size(); i++)
4163  NamedChain[i] = Chaining[i];
4164 
4166  SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
4167  VD->getType(), {NamedChain, Chaining.size()});
4168 
4169  for (const auto *Attr : VD->attrs())
4170  IndirectField->addAttr(Attr->clone(SemaRef.Context));
4171 
4172  IndirectField->setAccess(AS);
4173  IndirectField->setImplicit();
4174  SemaRef.PushOnScopeChains(IndirectField, S);
4175 
4176  // That includes picking up the appropriate access specifier.
4177  if (AS != AS_none) IndirectField->setAccess(AS);
4178 
4179  Chaining.resize(OldChainingSize);
4180  }
4181  }
4182  }
4183 
4184  return Invalid;
4185 }
4186 
4187 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
4188 /// a VarDecl::StorageClass. Any error reporting is up to the caller:
4189 /// illegal input values are mapped to SC_None.
4190 static StorageClass
4192  DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
4193  assert(StorageClassSpec != DeclSpec::SCS_typedef &&
4194  "Parser allowed 'typedef' as storage class VarDecl.");
4195  switch (StorageClassSpec) {
4196  case DeclSpec::SCS_unspecified: return SC_None;
4197  case DeclSpec::SCS_extern:
4198  if (DS.isExternInLinkageSpec())
4199  return SC_None;
4200  return SC_Extern;
4201  case DeclSpec::SCS_static: return SC_Static;
4202  case DeclSpec::SCS_auto: return SC_Auto;
4203  case DeclSpec::SCS_register: return SC_Register;
4205  // Illegal SCSs map to None: error reporting is up to the caller.
4206  case DeclSpec::SCS_mutable: // Fall through.
4207  case DeclSpec::SCS_typedef: return SC_None;
4208  }
4209  llvm_unreachable("unknown storage class specifier");
4210 }
4211 
4213  assert(Record->hasInClassInitializer());
4214 
4215  for (const auto *I : Record->decls()) {
4216  const auto *FD = dyn_cast<FieldDecl>(I);
4217  if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
4218  FD = IFD->getAnonField();
4219  if (FD && FD->hasInClassInitializer())
4220  return FD->getLocation();
4221  }
4222 
4223  llvm_unreachable("couldn't find in-class initializer");
4224 }
4225 
4227  SourceLocation DefaultInitLoc) {
4228  if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4229  return;
4230 
4231  S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
4232  S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
4233 }
4234 
4236  CXXRecordDecl *AnonUnion) {
4237  if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4238  return;
4239 
4240  checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
4241 }
4242 
4243 /// BuildAnonymousStructOrUnion - Handle the declaration of an
4244 /// anonymous structure or union. Anonymous unions are a C++ feature
4245 /// (C++ [class.union]) and a C11 feature; anonymous structures
4246 /// are a C11 feature and GNU C++ extension.
4248  AccessSpecifier AS,
4249  RecordDecl *Record,
4250  const PrintingPolicy &Policy) {
4251  DeclContext *Owner = Record->getDeclContext();
4252 
4253  // Diagnose whether this anonymous struct/union is an extension.
4254  if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
4255  Diag(Record->getLocation(), diag::ext_anonymous_union);
4256  else if (!Record->isUnion() && getLangOpts().CPlusPlus)
4257  Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
4258  else if (!Record->isUnion() && !getLangOpts().C11)
4259  Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
4260 
4261  // C and C++ require different kinds of checks for anonymous
4262  // structs/unions.
4263  bool Invalid = false;
4264  if (getLangOpts().CPlusPlus) {
4265  const char *PrevSpec = nullptr;
4266  unsigned DiagID;
4267  if (Record->isUnion()) {
4268  // C++ [class.union]p6:
4269  // Anonymous unions declared in a named namespace or in the
4270  // global namespace shall be declared static.
4272  (isa<TranslationUnitDecl>(Owner) ||
4273  (isa<NamespaceDecl>(Owner) &&
4274  cast<NamespaceDecl>(Owner)->getDeclName()))) {
4275  Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
4276  << FixItHint::CreateInsertion(Record->getLocation(), "static ");
4277 
4278  // Recover by adding 'static'.
4280  PrevSpec, DiagID, Policy);
4281  }
4282  // C++ [class.union]p6:
4283  // A storage class is not allowed in a declaration of an
4284  // anonymous union in a class scope.
4286  isa<RecordDecl>(Owner)) {
4288  diag::err_anonymous_union_with_storage_spec)
4290 
4291  // Recover by removing the storage specifier.
4293  SourceLocation(),
4294  PrevSpec, DiagID, Context.getPrintingPolicy());
4295  }
4296  }
4297 
4298  // Ignore const/volatile/restrict qualifiers.
4299  if (DS.getTypeQualifiers()) {
4301  Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
4302  << Record->isUnion() << "const"
4305  Diag(DS.getVolatileSpecLoc(),
4306  diag::ext_anonymous_struct_union_qualified)
4307  << Record->isUnion() << "volatile"
4310  Diag(DS.getRestrictSpecLoc(),
4311  diag::ext_anonymous_struct_union_qualified)
4312  << Record->isUnion() << "restrict"
4315  Diag(DS.getAtomicSpecLoc(),
4316  diag::ext_anonymous_struct_union_qualified)
4317  << Record->isUnion() << "_Atomic"
4321  diag::ext_anonymous_struct_union_qualified)
4322  << Record->isUnion() << "__unaligned"
4324 
4325  DS.ClearTypeQualifiers();
4326  }
4327 
4328  // C++ [class.union]p2:
4329  // The member-specification of an anonymous union shall only
4330  // define non-static data members. [Note: nested types and
4331  // functions cannot be declared within an anonymous union. ]
4332  for (auto *Mem : Record->decls()) {
4333  if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
4334  // C++ [class.union]p3:
4335  // An anonymous union shall not have private or protected
4336  // members (clause 11).
4337  assert(FD->getAccess() != AS_none);
4338  if (FD->getAccess() != AS_public) {
4339  Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
4340  << Record->isUnion() << (FD->getAccess() == AS_protected);
4341  Invalid = true;
4342  }
4343 
4344  // C++ [class.union]p1
4345  // An object of a class with a non-trivial constructor, a non-trivial
4346  // copy constructor, a non-trivial destructor, or a non-trivial copy
4347  // assignment operator cannot be a member of a union, nor can an
4348  // array of such objects.
4349  if (CheckNontrivialField(FD))
4350  Invalid = true;
4351  } else if (Mem->isImplicit()) {
4352  // Any implicit members are fine.
4353  } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
4354  // This is a type that showed up in an
4355  // elaborated-type-specifier inside the anonymous struct or
4356  // union, but which actually declares a type outside of the
4357  // anonymous struct or union. It's okay.
4358  } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
4359  if (!MemRecord->isAnonymousStructOrUnion() &&
4360  MemRecord->getDeclName()) {
4361  // Visual C++ allows type definition in anonymous struct or union.
4362  if (getLangOpts().MicrosoftExt)
4363  Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
4364  << Record->isUnion();
4365  else {
4366  // This is a nested type declaration.
4367  Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
4368  << Record->isUnion();
4369  Invalid = true;
4370  }
4371  } else {
4372  // This is an anonymous type definition within another anonymous type.
4373  // This is a popular extension, provided by Plan9, MSVC and GCC, but
4374  // not part of standard C++.
4375  Diag(MemRecord->getLocation(),
4376  diag::ext_anonymous_record_with_anonymous_type)
4377  << Record->isUnion();
4378  }
4379  } else if (isa<AccessSpecDecl>(Mem)) {
4380  // Any access specifier is fine.
4381  } else if (isa<StaticAssertDecl>(Mem)) {
4382  // In C++1z, static_assert declarations are also fine.
4383  } else {
4384  // We have something that isn't a non-static data
4385  // member. Complain about it.
4386  unsigned DK = diag::err_anonymous_record_bad_member;
4387  if (isa<TypeDecl>(Mem))
4388  DK = diag::err_anonymous_record_with_type;
4389  else if (isa<FunctionDecl>(Mem))
4390  DK = diag::err_anonymous_record_with_function;
4391  else if (isa<VarDecl>(Mem))
4392  DK = diag::err_anonymous_record_with_static;
4393 
4394  // Visual C++ allows type definition in anonymous struct or union.
4395  if (getLangOpts().MicrosoftExt &&
4396  DK == diag::err_anonymous_record_with_type)
4397  Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
4398  << Record->isUnion();
4399  else {
4400  Diag(Mem->getLocation(), DK) << Record->isUnion();
4401  Invalid = true;
4402  }
4403  }
4404  }
4405 
4406  // C++11 [class.union]p8 (DR1460):
4407  // At most one variant member of a union may have a
4408  // brace-or-equal-initializer.
4409  if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
4410  Owner->isRecord())
4411  checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
4412  cast<CXXRecordDecl>(Record));
4413  }
4414 
4415  if (!Record->isUnion() && !Owner->isRecord()) {
4416  Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
4417  << getLangOpts().CPlusPlus;
4418  Invalid = true;
4419  }
4420 
4421  // Mock up a declarator.
4423  TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4424  assert(TInfo && "couldn't build declarator info for anonymous struct/union");
4425 
4426  // Create a declaration for this anonymous struct/union.
4427  NamedDecl *Anon = nullptr;
4428  if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
4429  Anon = FieldDecl::Create(Context, OwningClass,
4430  DS.getLocStart(),
4431  Record->getLocation(),
4432  /*IdentifierInfo=*/nullptr,
4433  Context.getTypeDeclType(Record),
4434  TInfo,
4435  /*BitWidth=*/nullptr, /*Mutable=*/false,
4436  /*InitStyle=*/ICIS_NoInit);
4437  Anon->setAccess(AS);
4438  if (getLangOpts().CPlusPlus)
4439  FieldCollector->Add(cast<FieldDecl>(Anon));
4440  } else {
4441  DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
4443  if (SCSpec == DeclSpec::SCS_mutable) {
4444  // mutable can only appear on non-static class members, so it's always
4445  // an error here
4446  Diag(Record->getLocation(), diag::err_mutable_nonmember);
4447  Invalid = true;
4448  SC = SC_None;
4449  }
4450 
4451  Anon = VarDecl::Create(Context, Owner,
4452  DS.getLocStart(),
4453  Record->getLocation(), /*IdentifierInfo=*/nullptr,
4454  Context.getTypeDeclType(Record),
4455  TInfo, SC);
4456 
4457  // Default-initialize the implicit variable. This initialization will be
4458  // trivial in almost all cases, except if a union member has an in-class
4459  // initializer:
4460  // union { int n = 0; };
4461  ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
4462  }
4463  Anon->setImplicit();
4464 
4465  // Mark this as an anonymous struct/union type.
4466  Record->setAnonymousStructOrUnion(true);
4467 
4468  // Add the anonymous struct/union object to the current
4469  // context. We'll be referencing this object when we refer to one of
4470  // its members.
4471  Owner->addDecl(Anon);
4472 
4473  // Inject the members of the anonymous struct/union into the owning
4474  // context and into the identifier resolver chain for name lookup
4475  // purposes.
4477  Chain.push_back(Anon);
4478 
4479  if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, Chain))
4480  Invalid = true;
4481 
4482  if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
4483  if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
4484  Decl *ManglingContextDecl;
4485  if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
4486  NewVD->getDeclContext(), ManglingContextDecl)) {
4488  NewVD, MCtx->getManglingNumber(
4489  NewVD, getMSManglingNumber(getLangOpts(), S)));
4490  Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4491  }
4492  }
4493  }
4494 
4495  if (Invalid)
4496  Anon->setInvalidDecl();
4497 
4498  return Anon;
4499 }
4500 
4501 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4502 /// Microsoft C anonymous structure.
4503 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4504 /// Example:
4505 ///
4506 /// struct A { int a; };
4507 /// struct B { struct A; int b; };
4508 ///
4509 /// void foo() {
4510 /// B var;
4511 /// var.a = 3;
4512 /// }
4513 ///
4515  RecordDecl *Record) {
4516  assert(Record && "expected a record!");
4517 
4518  // Mock up a declarator.
4520  TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4521  assert(TInfo && "couldn't build declarator info for anonymous struct");
4522 
4523  auto *ParentDecl = cast<RecordDecl>(CurContext);
4524  QualType RecTy = Context.getTypeDeclType(Record);
4525 
4526  // Create a declaration for this anonymous struct.
4528  ParentDecl,
4529  DS.getLocStart(),
4530  DS.getLocStart(),
4531  /*IdentifierInfo=*/nullptr,
4532  RecTy,
4533  TInfo,
4534  /*BitWidth=*/nullptr, /*Mutable=*/false,
4535  /*InitStyle=*/ICIS_NoInit);
4536  Anon->setImplicit();
4537 
4538  // Add the anonymous struct object to the current context.
4539  CurContext->addDecl(Anon);
4540 
4541  // Inject the members of the anonymous struct into the current
4542  // context and into the identifier resolver chain for name lookup
4543  // purposes.
4545  Chain.push_back(Anon);
4546 
4547  RecordDecl *RecordDef = Record->getDefinition();
4548  if (RequireCompleteType(Anon->getLocation(), RecTy,
4549  diag::err_field_incomplete) ||
4550  InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
4551  AS_none, Chain)) {
4552  Anon->setInvalidDecl();
4553  ParentDecl->setInvalidDecl();
4554  }
4555 
4556  return Anon;
4557 }
4558 
4559 /// GetNameForDeclarator - Determine the full declaration name for the
4560 /// given Declarator.
4562  return GetNameFromUnqualifiedId(D.getName());
4563 }
4564 
4565 /// \brief Retrieves the declaration name from a parsed unqualified-id.
4568  DeclarationNameInfo NameInfo;
4569  NameInfo.setLoc(Name.StartLocation);
4570 
4571  switch (Name.getKind()) {
4572 
4575  NameInfo.setName(Name.Identifier);
4576  NameInfo.setLoc(Name.StartLocation);
4577  return NameInfo;
4578 
4582  NameInfo.setLoc(Name.StartLocation);
4586  = Name.EndLocation.getRawEncoding();
4587  return NameInfo;
4588 
4591  Name.Identifier));
4592  NameInfo.setLoc(Name.StartLocation);
4594  return NameInfo;
4595 
4597  TypeSourceInfo *TInfo;
4598  QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4599  if (Ty.isNull())
4600  return DeclarationNameInfo();
4602  Context.getCanonicalType(Ty)));
4603  NameInfo.setLoc(Name.StartLocation);
4604  NameInfo.setNamedTypeInfo(TInfo);
4605  return NameInfo;
4606  }
4607 
4609  TypeSourceInfo *TInfo;
4610  QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
4611  if (Ty.isNull())
4612  return DeclarationNameInfo();
4614  Context.getCanonicalType(Ty)));
4615  NameInfo.setLoc(Name.StartLocation);
4616  NameInfo.setNamedTypeInfo(TInfo);
4617  return NameInfo;
4618  }
4619 
4621  // In well-formed code, we can only have a constructor
4622  // template-id that refers to the current context, so go there
4623  // to find the actual type being constructed.
4624  CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
4625  if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
4626  return DeclarationNameInfo();
4627 
4628  // Determine the type of the class being constructed.
4629  QualType CurClassType = Context.getTypeDeclType(CurClass);
4630 
4631  // FIXME: Check two things: that the template-id names the same type as
4632  // CurClassType, and that the template-id does not occur when the name
4633  // was qualified.
4634 
4636  Context.getCanonicalType(CurClassType)));
4637  NameInfo.setLoc(Name.StartLocation);
4638  // FIXME: should we retrieve TypeSourceInfo?
4639  NameInfo.setNamedTypeInfo(nullptr);
4640  return NameInfo;
4641  }
4642 
4644  TypeSourceInfo *TInfo;
4645  QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
4646  if (Ty.isNull())
4647  return DeclarationNameInfo();
4649  Context.getCanonicalType(Ty)));
4650  NameInfo.setLoc(Name.StartLocation);
4651  NameInfo.setNamedTypeInfo(TInfo);
4652  return NameInfo;
4653  }
4654 
4656  TemplateName TName = Name.TemplateId->Template.get();
4657  SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
4658  return Context.getNameForTemplate(TName, TNameLoc);
4659  }
4660 
4661  } // switch (Name.getKind())
4662 
4663  llvm_unreachable("Unknown name kind");
4664 }
4665 
4667  do {
4668  if (Ty->isPointerType() || Ty->isReferenceType())
4669  Ty = Ty->getPointeeType();
4670  else if (Ty->isArrayType())
4671  Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
4672  else
4673  return Ty.withoutLocalFastQualifiers();
4674  } while (true);
4675 }
4676 
4677 /// hasSimilarParameters - Determine whether the C++ functions Declaration
4678 /// and Definition have "nearly" matching parameters. This heuristic is
4679 /// used to improve diagnostics in the case where an out-of-line function
4680 /// definition doesn't match any declaration within the class or namespace.
4681 /// Also sets Params to the list of indices to the parameters that differ
4682 /// between the declaration and the definition. If hasSimilarParameters
4683 /// returns true and Params is empty, then all of the parameters match.
4685  FunctionDecl *Declaration,
4686  FunctionDecl *Definition,
4687  SmallVectorImpl<unsigned> &Params) {
4688  Params.clear();
4689  if (Declaration->param_size() != Definition->param_size())
4690  return false;
4691  for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
4692  QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
4693  QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
4694 
4695  // The parameter types are identical
4696  if (Context.hasSameType(DefParamTy, DeclParamTy))
4697  continue;
4698 
4699  QualType DeclParamBaseTy = getCoreType(DeclParamTy);
4700  QualType DefParamBaseTy = getCoreType(DefParamTy);
4701  const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
4702  const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
4703 
4704  if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
4705  (DeclTyName && DeclTyName == DefTyName))
4706  Params.push_back(Idx);
4707  else // The two parameters aren't even close
4708  return false;
4709  }
4710 
4711  return true;
4712 }
4713 
4714 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given
4715 /// declarator needs to be rebuilt in the current instantiation.
4716 /// Any bits of declarator which appear before the name are valid for
4717 /// consideration here. That's specifically the type in the decl spec
4718 /// and the base type in any member-pointer chunks.
4721  // The types we specifically need to rebuild are:
4722  // - typenames, typeofs, and decltypes
4723  // - types which will become injected class names
4724  // Of course, we also need to rebuild any type referencing such a
4725  // type. It's safest to just say "dependent", but we call out a
4726  // few cases here.
4727 
4728  DeclSpec &DS = D.getMutableDeclSpec();
4729  switch (DS.getTypeSpecType()) {
4733  case DeclSpec::TST_atomic: {
4734  // Grab the type from the parser.
4735  TypeSourceInfo *TSI = nullptr;
4736  QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
4737  if (T.isNull() || !T->isDependentType()) break;
4738 
4739  // Make sure there's a type source info. This isn't really much
4740  // of a waste; most dependent types should have type source info
4741  // attached already.
4742  if (!TSI)
4744 
4745  // Rebuild the type in the current instantiation.
4747  if (!TSI) return true;
4748 
4749  // Store the new type back in the decl spec.
4750  ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
4751  DS.UpdateTypeRep(LocType);
4752  break;
4753  }
4754 
4756  case DeclSpec::TST_typeofExpr: {
4757  Expr *E = DS.getRepAsExpr();
4759  if (Result.isInvalid()) return true;
4760  DS.UpdateExprRep(Result.get());
4761  break;
4762  }
4763 
4764  default:
4765  // Nothing to do for these decl specs.
4766  break;
4767  }
4768 
4769  // It doesn't matter what order we do this in.
4770  for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4771  DeclaratorChunk &Chunk = D.getTypeObject(I);
4772 
4773  // The only type information in the declarator which can come
4774  // before the declaration name is the base type of a member
4775  // pointer.
4776  if (Chunk.Kind != DeclaratorChunk::MemberPointer)
4777  continue;
4778 
4779  // Rebuild the scope specifier in-place.
4780  CXXScopeSpec &SS = Chunk.Mem.Scope();
4782  return true;
4783  }
4784 
4785  return false;
4786 }
4787 
4790  Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
4791 
4792  if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
4793  Dcl && Dcl->getDeclContext()->isFileContext())
4794  Dcl->setTopLevelDeclInObjCContainer();
4795 
4796  return Dcl;
4797 }
4798 
4799 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
4800 /// If T is the name of a class, then each of the following shall have a
4801 /// name different from T:
4802 /// - every static data member of class T;
4803 /// - every member function of class T
4804 /// - every member of class T that is itself a type;
4805 /// \returns true if the declaration name violates these rules.
4807  DeclarationNameInfo NameInfo) {
4808  DeclarationName Name = NameInfo.getName();
4809 
4810  CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC);
4811  while (Record && Record->isAnonymousStructOrUnion())
4812  Record = dyn_cast<CXXRecordDecl>(Record->getParent());
4813  if (Record && Record->getIdentifier() && Record->getDeclName() == Name) {
4814  Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
4815  return true;
4816  }
4817 
4818  return false;
4819 }
4820 
4821 /// \brief Diagnose a declaration whose declarator-id has the given
4822 /// nested-name-specifier.
4823 ///
4824 /// \param SS The nested-name-specifier of the declarator-id.
4825 ///
4826 /// \param DC The declaration context to which the nested-name-specifier
4827 /// resolves.
4828 ///
4829 /// \param Name The name of the entity being declared.
4830 ///
4831 /// \param Loc The location of the name of the entity being declared.
4832 ///
4833 /// \returns true if we cannot safely recover from this error, false otherwise.
4836  SourceLocation Loc) {
4837  DeclContext *Cur = CurContext;
4838  while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
4839  Cur = Cur->getParent();
4840 
4841  // If the user provided a superfluous scope specifier that refers back to the
4842  // class in which the entity is already declared, diagnose and ignore it.
4843  //
4844  // class X {
4845  // void X::f();
4846  // };
4847  //
4848  // Note, it was once ill-formed to give redundant qualification in all
4849  // contexts, but that rule was removed by DR482.
4850  if (Cur->Equals(DC)) {
4851  if (Cur->isRecord()) {
4852  Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
4853  : diag::err_member_extra_qualification)
4854  << Name << FixItHint::CreateRemoval(SS.getRange());
4855  SS.clear();
4856  } else {
4857  Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
4858  }
4859  return false;
4860  }
4861 
4862  // Check whether the qualifying scope encloses the scope of the original
4863  // declaration.
4864  if (!Cur->Encloses(DC)) {
4865  if (Cur->isRecord())
4866  Diag(Loc, diag::err_member_qualification)
4867  << Name << SS.getRange();
4868  else if (isa<TranslationUnitDecl>(DC))
4869  Diag(Loc, diag::err_invalid_declarator_global_scope)
4870  << Name << SS.getRange();
4871  else if (isa<FunctionDecl>(Cur))
4872  Diag(Loc, diag::err_invalid_declarator_in_function)
4873  << Name << SS.getRange();
4874  else if (isa<BlockDecl>(Cur))
4875  Diag(Loc, diag::err_invalid_declarator_in_block)
4876  << Name << SS.getRange();
4877  else
4878  Diag(Loc, diag::err_invalid_declarator_scope)
4879  << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
4880 
4881  return true;
4882  }
4883 
4884  if (Cur->isRecord()) {
4885  // Cannot qualify members within a class.
4886  Diag(Loc, diag::err_member_qualification)
4887  << Name << SS.getRange();
4888  SS.clear();
4889 
4890  // C++ constructors and destructors with incorrect scopes can break
4891  // our AST invariants by having the wrong underlying types. If
4892  // that's the case, then drop this declaration entirely.
4896  Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
4897  return true;
4898 
4899  return false;
4900  }
4901 
4902  // C++11 [dcl.meaning]p1:
4903  // [...] "The nested-name-specifier of the qualified declarator-id shall
4904  // not begin with a decltype-specifer"
4905  NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
4906  while (SpecLoc.getPrefix())
4907  SpecLoc = SpecLoc.getPrefix();
4908  if (dyn_cast_or_null<DecltypeType>(
4909  SpecLoc.getNestedNameSpecifier()->getAsType()))
4910  Diag(Loc, diag::err_decltype_in_declarator)
4911  << SpecLoc.getTypeLoc().getSourceRange();
4912 
4913  return false;
4914 }
4915 
4917  MultiTemplateParamsArg TemplateParamLists) {
4918  // TODO: consider using NameInfo for diagnostic.
4919  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4920  DeclarationName Name = NameInfo.getName();
4921 
4922  // All of these full declarators require an identifier. If it doesn't have
4923  // one, the ParsedFreeStandingDeclSpec action should be used.
4924  if (!Name) {
4925  if (!D.isInvalidType()) // Reject this if we think it is valid.
4927  diag::err_declarator_need_ident)
4928  << D.getDeclSpec().getSourceRange() << D.getSourceRange();
4929  return nullptr;
4930  } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
4931  return nullptr;
4932 
4933  // The scope passed in may not be a decl scope. Zip up the scope tree until
4934  // we find one that is.
4935  while ((S->getFlags() & Scope::DeclScope) == 0 ||
4936  (S->getFlags() & Scope::TemplateParamScope) != 0)
4937  S = S->getParent();
4938 
4939  DeclContext *DC = CurContext;
4940  if (D.getCXXScopeSpec().isInvalid())
4941  D.setInvalidType();
4942  else if (D.getCXXScopeSpec().isSet()) {
4943  if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
4944  UPPC_DeclarationQualifier))
4945  return nullptr;
4946 
4947  bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
4948  DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
4949  if (!DC || isa<EnumDecl>(DC)) {
4950  // If we could not compute the declaration context, it's because the
4951  // declaration context is dependent but does not refer to a class,
4952  // class template, or class template partial specialization. Complain
4953  // and return early, to avoid the coming semantic disaster.
4954  Diag(D.getIdentifierLoc(),
4955  diag::err_template_qualified_declarator_no_match)
4956  << D.getCXXScopeSpec().getScopeRep()
4957  << D.getCXXScopeSpec().getRange();
4958  return nullptr;
4959  }
4960  bool IsDependentContext = DC->isDependentContext();
4961 
4962  if (!IsDependentContext &&
4963  RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
4964  return nullptr;
4965 
4966  // If a class is incomplete, do not parse entities inside it.
4967  if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
4968  Diag(D.getIdentifierLoc(),
4969  diag::err_member_def_undefined_record)
4970  << Name << DC << D.getCXXScopeSpec().getRange();
4971  return nullptr;
4972  }
4973  if (!D.getDeclSpec().isFriendSpecified()) {
4974  if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
4975  Name, D.getIdentifierLoc())) {
4976  if (DC->isRecord())
4977  return nullptr;
4978 
4979  D.setInvalidType();
4980  }
4981  }
4982 
4983  // Check whether we need to rebuild the type of the given
4984  // declaration in the current instantiation.
4985  if (EnteringContext && IsDependentContext &&
4986  TemplateParamLists.size() != 0) {
4987  ContextRAII SavedContext(*this, DC);
4988  if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
4989  D.setInvalidType();
4990  }
4991  }
4992 
4993  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4994  QualType R = TInfo->getType();
4995 
4996  if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo))
4997  // If this is a typedef, we'll end up spewing multiple diagnostics.
4998  // Just return early; it's safer. If this is a function, let the
4999  // "constructor cannot have a return type" diagnostic handle it.
5001  return nullptr;
5002 
5003  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
5004  UPPC_DeclarationType))
5005  D.setInvalidType();
5006 
5007  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
5008  ForRedeclaration);
5009 
5010  // See if this is a redefinition of a variable in the same scope.
5011  if (!D.getCXXScopeSpec().isSet()) {
5012  bool IsLinkageLookup = false;
5013  bool CreateBuiltins = false;
5014 
5015  // If the declaration we're planning to build will be a function
5016  // or object with linkage, then look for another declaration with
5017  // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
5018  //
5019  // If the declaration we're planning to build will be declared with
5020  // external linkage in the translation unit, create any builtin with
5021  // the same name.
5023  /* Do nothing*/;
5024  else if (CurContext->isFunctionOrMethod() &&
5026  R->isFunctionType())) {
5027  IsLinkageLookup = true;
5028  CreateBuiltins =
5029  CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
5030  } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
5032  CreateBuiltins = true;
5033 
5034  if (IsLinkageLookup)
5035  Previous.clear(LookupRedeclarationWithLinkage);
5036 
5037  LookupName(Previous, S, CreateBuiltins);
5038  } else { // Something like "int foo::x;"
5039  LookupQualifiedName(Previous, DC);
5040 
5041  // C++ [dcl.meaning]p1:
5042  // When the declarator-id is qualified, the declaration shall refer to a
5043  // previously declared member of the class or namespace to which the
5044  // qualifier refers (or, in the case of a namespace, of an element of the
5045  // inline namespace set of that namespace (7.3.1)) or to a specialization
5046  // thereof; [...]
5047  //
5048  // Note that we already checked the context above, and that we do not have
5049  // enough information to make sure that Previous contains the declaration
5050  // we want to match. For example, given:
5051  //
5052  // class X {
5053  // void f();
5054  // void f(float);
5055  // };
5056  //
5057  // void X::f(int) { } // ill-formed
5058  //
5059  // In this case, Previous will point to the overload set
5060  // containing the two f's declared in X, but neither of them
5061  // matches.
5062 
5063  // C++ [dcl.meaning]p1:
5064  // [...] the member shall not merely have been introduced by a
5065  // using-declaration in the scope of the class or namespace nominated by
5066  // the nested-name-specifier of the declarator-id.
5067  RemoveUsingDecls(Previous);
5068  }
5069 
5070  if (Previous.isSingleResult() &&
5071  Previous.getFoundDecl()->isTemplateParameter()) {
5072  // Maybe we will complain about the shadowed template parameter.
5073  if (!D.isInvalidType())
5074  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
5075  Previous.getFoundDecl());
5076 
5077  // Just pretend that we didn't see the previous declaration.
5078  Previous.clear();
5079  }
5080 
5081  // In C++, the previous declaration we find might be a tag type
5082  // (class or enum). In this case, the new declaration will hide the
5083  // tag type. Note that this does does not apply if we're declaring a
5084  // typedef (C++ [dcl.typedef]p4).
5085  if (Previous.isSingleTagDecl() &&
5087  Previous.clear();
5088 
5089  // Check that there are no default arguments other than in the parameters
5090  // of a function declaration (C++ only).
5091  if (getLangOpts().CPlusPlus)
5092  CheckExtraCXXDefaultArguments(D);
5093 
5094  if (D.getDeclSpec().isConceptSpecified()) {
5095  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
5096  // applied only to the definition of a function template or variable
5097  // template, declared in namespace scope
5098  if (!TemplateParamLists.size()) {
5100  diag:: err_concept_wrong_decl_kind);
5101  return nullptr;
5102  }
5103 
5104  if (!DC->getRedeclContext()->isFileContext()) {
5105  Diag(D.getIdentifierLoc(),
5106  diag::err_concept_decls_may_only_appear_in_namespace_scope);
5107  return nullptr;
5108  }
5109  }
5110 
5111  NamedDecl *New;
5112 
5113  bool AddToScope = true;
5115  if (TemplateParamLists.size()) {
5116  Diag(D.getIdentifierLoc(), diag::err_template_typedef);
5117  return nullptr;
5118  }
5119 
5120  New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
5121  } else if (R->isFunctionType()) {
5122  New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
5123  TemplateParamLists,
5124  AddToScope);
5125  } else {
5126  New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
5127  AddToScope);
5128  }
5129 
5130  if (!New)
5131  return nullptr;
5132 
5133  // If this has an identifier and is not a function template specialization,
5134  // add it to the scope stack.
5135  if (New->getDeclName() && AddToScope) {
5136  // Only make a locally-scoped extern declaration visible if it is the first
5137  // declaration of this entity. Qualified lookup for such an entity should
5138  // only find this declaration if there is no visible declaration of it.
5139  bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
5140  PushOnScopeChains(New, S, AddToContext);
5141  if (!AddToContext)
5142  CurContext->addHiddenDecl(New);
5143  }
5144 
5145  if (isInOpenMPDeclareTargetContext())
5146  checkDeclIsAllowedInOpenMPTarget(nullptr, New);
5147 
5148  return New;
5149 }
5150 
5151 /// Helper method to turn variable array types into constant array
5152 /// types in certain situations which would otherwise be errors (for
5153 /// GCC compatibility).
5156  bool &SizeIsNegative,
5157  llvm::APSInt &Oversized) {
5158  // This method tries to turn a variable array into a constant
5159  // array even when the size isn't an ICE. This is necessary
5160  // for compatibility with code that depends on gcc's buggy
5161  // constant expression folding, like struct {char x[(int)(char*)2];}
5162  SizeIsNegative = false;
5163  Oversized = 0;
5164 
5165  if (T->isDependentType())
5166  return QualType();
5167 
5168  QualifierCollector Qs;
5169  const Type *Ty = Qs.strip(T);
5170 
5171  if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
5172  QualType Pointee = PTy->getPointeeType();
5173  QualType FixedType =
5174  TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
5175  Oversized);
5176  if (FixedType.isNull()) return FixedType;
5177  FixedType = Context.getPointerType(FixedType);
5178  return Qs.apply(Context, FixedType);
5179  }
5180  if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
5181  QualType Inner = PTy->getInnerType();
5182  QualType FixedType =
5183  TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
5184  Oversized);
5185  if (FixedType.isNull()) return FixedType;
5186  FixedType = Context.getParenType(FixedType);
5187  return Qs.apply(Context, FixedType);
5188  }
5189 
5190  const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
5191  if (!VLATy)
5192  return QualType();
5193  // FIXME: We should probably handle this case
5194  if (VLATy->getElementType()->isVariablyModifiedType())
5195  return QualType();
5196 
5197  llvm::APSInt Res;
5198  if (!VLATy->getSizeExpr() ||
5199  !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
5200  return QualType();
5201 
5202  // Check whether the array size is negative.
5203  if (Res.isSigned() && Res.isNegative()) {
5204  SizeIsNegative = true;
5205  return QualType();
5206  }
5207 
5208  // Check whether the array is too large to be addressed.
5209  unsigned ActiveSizeBits
5211  Res);
5212  if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
5213  Oversized = Res;
5214  return QualType();
5215  }
5216 
5217  return Context.getConstantArrayType(VLATy->getElementType(),
5218  Res, ArrayType::Normal, 0);
5219 }
5220 
5221 static void
5223  SrcTL = SrcTL.getUnqualifiedLoc();
5224  DstTL = DstTL.getUnqualifiedLoc();
5225  if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
5226  PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
5227  FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
5228  DstPTL.getPointeeLoc());
5229  DstPTL.setStarLoc(SrcPTL.getStarLoc());
5230  return;
5231  }
5232  if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
5233  ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
5234  FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
5235  DstPTL.getInnerLoc());
5236  DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
5237  DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
5238  return;
5239  }
5240  ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
5241  ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
5242  TypeLoc SrcElemTL = SrcATL.getElementLoc();
5243  TypeLoc DstElemTL = DstATL.getElementLoc();
5244  DstElemTL.initializeFullCopy(SrcElemTL);
5245  DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
5246  DstATL.setSizeExpr(SrcATL.getSizeExpr());
5247  DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
5248 }
5249 
5250 /// Helper method to turn variable array types into constant array
5251 /// types in certain situations which would otherwise be errors (for
5252 /// GCC compatibility).
5253 static TypeSourceInfo*
5256  bool &SizeIsNegative,
5257  llvm::APSInt &Oversized) {
5258  QualType FixedTy
5260  SizeIsNegative, Oversized);
5261  if (FixedTy.isNull())
5262  return nullptr;
5263  TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
5265  FixedTInfo->getTypeLoc());
5266  return FixedTInfo;
5267 }
5268 
5269 /// \brief Register the given locally-scoped extern "C" declaration so
5270 /// that it can be found later for redeclarations. We include any extern "C"
5271 /// declaration that is not visible in the translation unit here, not just
5272 /// function-scope declarations.
5273 void
5275  if (!getLangOpts().CPlusPlus &&
5276  ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
5277  // Don't need to track declarations in the TU in C.
5278  return;
5279 
5280  // Note that we have a locally-scoped external with this name.
5282 }
5283 
5285  // FIXME: We can have multiple results via __attribute__((overloadable)).
5286  auto Result = Context.getExternCContextDecl()->lookup(Name);
5287  return Result.empty() ? nullptr : *Result.begin();
5288 }
5289 
5290 /// \brief Diagnose function specifiers on a declaration of an identifier that
5291 /// does not identify a function.
5293  // FIXME: We should probably indicate the identifier in question to avoid
5294  // confusion for constructs like "virtual int a(), b;"
5295  if (DS.isVirtualSpecified())
5296  Diag(DS.getVirtualSpecLoc(),
5297  diag::err_virtual_non_function);
5298 
5299  if (DS.isExplicitSpecified())
5300  Diag(DS.getExplicitSpecLoc(),
5301  diag::err_explicit_non_function);
5302 
5303  if (DS.isNoreturnSpecified())
5304  Diag(DS.getNoreturnSpecLoc(),
5305  diag::err_noreturn_non_function);
5306 }
5307 
5308 NamedDecl*
5311  // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
5312  if (D.getCXXScopeSpec().isSet()) {
5313  Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
5314  << D.getCXXScopeSpec().getRange();
5315  D.setInvalidType();
5316  // Pretend we didn't see the scope specifier.
5317  DC = CurContext;
5318  Previous.clear();
5319  }
5320 
5321  DiagnoseFunctionSpecifiers(D.getDeclSpec());
5322 
5323  if (D.getDeclSpec().isInlineSpecified())
5324  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
5325  << getLangOpts().CPlusPlus1z;
5327  Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
5328  << 1;
5329  if (D.getDeclSpec().isConceptSpecified())
5331  diag::err_concept_wrong_decl_kind);
5332 
5334  Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
5335  << D.getName().getSourceRange();
5336  return nullptr;
5337  }
5338 
5339  TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
5340  if (!NewTD) return nullptr;
5341 
5342  // Handle attributes prior to checking for duplicates in MergeVarDecl
5343  ProcessDeclAttributes(S, NewTD, D);
5344 
5345  CheckTypedefForVariablyModifiedType(S, NewTD);
5346 
5347  bool Redeclaration = D.isRedeclaration();
5348  NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
5349  D.setRedeclaration(Redeclaration);
5350  return ND;
5351 }
5352 
5353 void
5355  // C99 6.7.7p2: If a typedef name specifies a variably modified type
5356  // then it shall have block scope.
5357  // Note that variably modified types must be fixed before merging the decl so
5358  // that redeclarations will match.
5359  TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
5360  QualType T = TInfo->getType();
5361  if (T->isVariablyModifiedType()) {
5362  getCurFunction()->setHasBranchProtectedScope();
5363 
5364  if (S->getFnParent() == nullptr) {
5365  bool SizeIsNegative;
5366  llvm::APSInt Oversized;
5367  TypeSourceInfo *FixedTInfo =
5369  SizeIsNegative,
5370  Oversized);
5371  if (FixedTInfo) {
5372  Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
5373  NewTD->setTypeSourceInfo(FixedTInfo);
5374  } else {
5375  if (SizeIsNegative)
5376  Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
5377  else if (T->isVariableArrayType())
5378  Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
5379  else if (Oversized.getBoolValue())
5380  Diag(NewTD->getLocation(), diag::err_array_too_large)
5381  << Oversized.toString(10);
5382  else
5383  Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
5384  NewTD->setInvalidDecl();
5385  }
5386  }
5387  }
5388 }
5389 
5390 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
5391 /// declares a typedef-name, either using the 'typedef' type specifier or via
5392 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
5393 NamedDecl*
5395  LookupResult &Previous, bool &Redeclaration) {
5396  // Merge the decl with the existing one if appropriate. If the decl is
5397  // in an outer scope, it isn't the same thing.
5398  FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
5399  /*AllowInlineNamespace*/false);
5400  filterNonConflictingPreviousTypedefDecls(*this, NewTD, Previous);
5401  if (!Previous.empty()) {
5402  Redeclaration = true;
5403  MergeTypedefNameDecl(S, NewTD, Previous);
5404  }
5405 
5406  // If this is the C FILE type, notify the AST context.
5407  if (IdentifierInfo *II = NewTD->getIdentifier())
5408  if (!NewTD->isInvalidDecl() &&
5409  NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
5410  if (II->isStr("FILE"))
5411  Context.setFILEDecl(NewTD);
5412  else if (II->isStr("jmp_buf"))
5413  Context.setjmp_bufDecl(NewTD);
5414  else if (II->isStr("sigjmp_buf"))
5415  Context.setsigjmp_bufDecl(NewTD);
5416  else if (II->isStr("ucontext_t"))
5417  Context.setucontext_tDecl(NewTD);
5418  }
5419 
5420  return NewTD;
5421 }
5422 
5423 /// \brief Determines whether the given declaration is an out-of-scope
5424 /// previous declaration.
5425 ///
5426 /// This routine should be invoked when name lookup has found a
5427 /// previous declaration (PrevDecl) that is not in the scope where a
5428 /// new declaration by the same name is being introduced. If the new
5429 /// declaration occurs in a local scope, previous declarations with
5430 /// linkage may still be considered previous declarations (C99
5431 /// 6.2.2p4-5, C++ [basic.link]p6).
5432 ///
5433 /// \param PrevDecl the previous declaration found by name
5434 /// lookup
5435 ///
5436 /// \param DC the context in which the new declaration is being
5437 /// declared.
5438 ///
5439 /// \returns true if PrevDecl is an out-of-scope previous declaration
5440 /// for a new delcaration with the same name.
5441 static bool
5443  ASTContext &Context) {
5444  if (!PrevDecl)
5445  return false;
5446 
5447  if (!PrevDecl->hasLinkage())
5448  return false;
5449 
5450  if (Context.getLangOpts().CPlusPlus) {
5451  // C++ [basic.link]p6:
5452  // If there is a visible declaration of an entity with linkage
5453  // having the same name and type, ignoring entities declared
5454  // outside the innermost enclosing namespace scope, the block
5455  // scope declaration declares that same entity and receives the
5456  // linkage of the previous declaration.
5457  DeclContext *OuterContext = DC->getRedeclContext();
5458  if (!OuterContext->isFunctionOrMethod())
5459  // This rule only applies to block-scope declarations.
5460  return false;
5461 
5462  DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
5463  if (PrevOuterContext->isRecord())
5464  // We found a member function: ignore it.
5465  return false;
5466 
5467  // Find the innermost enclosing namespace for the new and
5468  // previous declarations.
5469  OuterContext = OuterContext->getEnclosingNamespaceContext();
5470  PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
5471 
5472  // The previous declaration is in a different namespace, so it
5473  // isn't the same function.
5474  if (!OuterContext->Equals(PrevOuterContext))
5475  return false;
5476  }
5477 
5478  return true;
5479 }
5480 
5482  CXXScopeSpec &SS = D.getCXXScopeSpec();
5483  if (!SS.isSet()) return;
5484  DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
5485 }
5486 
5488  QualType type = decl->getType();
5489  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5490  if (lifetime == Qualifiers::OCL_Autoreleasing) {
5491  // Various kinds of declaration aren't allowed to be __autoreleasing.
5492  unsigned kind = -1U;
5493  if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5494  if (var->hasAttr<BlocksAttr>())
5495  kind = 0; // __block
5496  else if (!var->hasLocalStorage())
5497  kind = 1; // global
5498  } else if (isa<ObjCIvarDecl>(decl)) {
5499  kind = 3; // ivar
5500  } else if (isa<FieldDecl>(decl)) {
5501  kind = 2; // field
5502  }
5503 
5504  if (kind != -1U) {
5505  Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
5506  << kind;
5507  }
5508  } else if (lifetime == Qualifiers::OCL_None) {
5509  // Try to infer lifetime.
5510  if (!type->isObjCLifetimeType())
5511  return false;
5512 
5513  lifetime = type->getObjCARCImplicitLifetime();
5514  type = Context.getLifetimeQualifiedType(type, lifetime);
5515  decl->setType(type);
5516  }
5517 
5518  if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5519  // Thread-local variables cannot have lifetime.
5520  if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
5521  var->getTLSKind()) {
5522  Diag(var->getLocation(), diag::err_arc_thread_ownership)
5523  << var->getType();
5524  return true;
5525  }
5526  }
5527 
5528  return false;
5529 }
5530 
5532  // Ensure that an auto decl is deduced otherwise the checks below might cache
5533  // the wrong linkage.
5534  assert(S.ParsingInitForAutoVars.count(&ND) == 0);
5535 
5536  // 'weak' only applies to declarations with external linkage.
5537  if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
5538  if (!ND.isExternallyVisible()) {
5539  S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5540  ND.dropAttr<WeakAttr>();
5541  }
5542  }
5543  if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
5544  if (ND.isExternallyVisible()) {
5545  S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5546  ND.dropAttr<WeakRefAttr>();
5547  ND.dropAttr<AliasAttr>();
5548  }
5549  }
5550 
5551  if (auto *VD = dyn_cast<VarDecl>(&ND)) {
5552  if (VD->hasInit()) {
5553  if (const auto *Attr = VD->getAttr<AliasAttr>()) {
5554  assert(VD->isThisDeclarationADefinition() &&
5555  !VD->isExternallyVisible() && "Broken AliasAttr handled late!");
5556  S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0;
5557  VD->dropAttr<AliasAttr>();
5558  }
5559  }
5560  }
5561 
5562  // 'selectany' only applies to externally visible variable declarations.
5563  // It does not apply to functions.
5564  if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5565  if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
5566  S.Diag(Attr->getLocation(),
5567  diag::err_attribute_selectany_non_extern_data);
5568  ND.dropAttr<SelectAnyAttr>();
5569  }
5570  }
5571 
5572  if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
5573  // dll attributes require external linkage. Static locals may have external
5574  // linkage but still cannot be explicitly imported or exported.
5575  auto *VD = dyn_cast<VarDecl>(&ND);
5576  if (!ND.isExternallyVisible() || (VD && VD->isStaticLocal())) {
5577  S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5578  << &ND << Attr;
5579  ND.setInvalidDecl();
5580  }
5581  }
5582 
5583  // Virtual functions cannot be marked as 'notail'.
5584  if (auto *Attr = ND.getAttr<NotTailCalledAttr>())
5585  if (auto *MD = dyn_cast<CXXMethodDecl>(&ND))
5586  if (MD->isVirtual()) {
5587  S.Diag(ND.getLocation(),
5588  diag::err_invalid_attribute_on_virtual_function)
5589  << Attr;
5590  ND.dropAttr<NotTailCalledAttr>();
5591  }
5592 }
5593 
5595  NamedDecl *NewDecl,
5596  bool IsSpecialization,
5597  bool IsDefinition) {
5598  if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) {
5599  OldDecl = OldTD->getTemplatedDecl();
5600  if (!IsSpecialization)
5601  IsDefinition = false;
5602  }
5603  if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl))
5604  NewDecl = NewTD->getTemplatedDecl();
5605 
5606  if (!OldDecl || !NewDecl)
5607  return;
5608 
5609  const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
5610  const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
5611  const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
5612  const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
5613 
5614  // dllimport and dllexport are inheritable attributes so we have to exclude
5615  // inherited attribute instances.
5616  bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
5617  (NewExportAttr && !NewExportAttr->isInherited());
5618 
5619  // A redeclaration is not allowed to add a dllimport or dllexport attribute,
5620  // the only exception being explicit specializations.
5621  // Implicitly generated declarations are also excluded for now because there
5622  // is no other way to switch these to use dllimport or dllexport.
5623  bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
5624 
5625  if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
5626  // Allow with a warning for free functions and global variables.
5627  bool JustWarn = false;
5628  if (!OldDecl->isCXXClassMember()) {
5629  auto *VD = dyn_cast<VarDecl>(OldDecl);
5630  if (VD && !VD->getDescribedVarTemplate())
5631  JustWarn = true;
5632  auto *FD = dyn_cast<FunctionDecl>(OldDecl);
5633  if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
5634  JustWarn = true;
5635  }
5636 
5637  // We cannot change a declaration that's been used because IR has already
5638  // been emitted. Dllimported functions will still work though (modulo
5639  // address equality) as they can use the thunk.
5640  if (OldDecl->isUsed())
5641  if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
5642  JustWarn = false;
5643 
5644  unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
5645  : diag::err_attribute_dll_redeclaration;
5646  S.Diag(NewDecl->getLocation(), DiagID)
5647  << NewDecl
5648  << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
5649  S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5650  if (!JustWarn) {
5651  NewDecl->setInvalidDecl();
5652  return;
5653  }
5654  }
5655 
5656  // A redeclaration is not allowed to drop a dllimport attribute, the only
5657  // exceptions being inline function definitions, local extern declarations,
5658  // qualified friend declarations or special MSVC extension: in the last case,
5659  // the declaration is treated as if it were marked dllexport.
5660  bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
5661  bool IsMicrosoft = S.Context.getTargetInfo().getCXXABI().isMicrosoft();
5662  if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) {
5663  // Ignore static data because out-of-line definitions are diagnosed
5664  // separately.
5665  IsStaticDataMember = VD->isStaticDataMember();
5666  IsDefinition = VD->isThisDeclarationADefinition(S.Context) !=
5668  } else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
5669  IsInline = FD->isInlined();
5670  IsQualifiedFriend = FD->getQualifier() &&
5671  FD->getFriendObjectKind() == Decl::FOK_Declared;
5672  }
5673 
5674  if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember &&
5675  !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
5676  if (IsMicrosoft && IsDefinition) {
5677  S.Diag(NewDecl->getLocation(),
5678  diag::warn_redeclaration_without_import_attribute)
5679  << NewDecl;
5680  S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5681  NewDecl->dropAttr<DLLImportAttr>();
5682  NewDecl->addAttr(::new (S.Context) DLLExportAttr(
5683  NewImportAttr->getRange(), S.Context,
5684  NewImportAttr->getSpellingListIndex()));
5685  } else {
5686  S.Diag(NewDecl->getLocation(),
5687  diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
5688  << NewDecl << OldImportAttr;
5689  S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5690  S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
5691  OldDecl->dropAttr<DLLImportAttr>();
5692  NewDecl->dropAttr<DLLImportAttr>();
5693  }
5694  } else if (IsInline && OldImportAttr && !IsMicrosoft) {
5695  // In MinGW, seeing a function declared inline drops the dllimport attribute.
5696  OldDecl->dropAttr<DLLImportAttr>();
5697  NewDecl->dropAttr<DLLImportAttr>();
5698  S.Diag(NewDecl->getLocation(),
5699  diag::warn_dllimport_dropped_from_inline_function)
5700  << NewDecl << OldImportAttr;
5701  }
5702 }
5703 
5704 /// Given that we are within the definition of the given function,
5705 /// will that definition behave like C99's 'inline', where the
5706 /// definition is discarded except for optimization purposes?
5708  // Try to avoid calling GetGVALinkageForFunction.
5709 
5710  // All cases of this require the 'inline' keyword.
5711  if (!FD->isInlined()) return false;
5712 
5713  // This is only possible in C++ with the gnu_inline attribute.
5714  if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
5715  return false;
5716 
5717  // Okay, go ahead and call the relatively-more-expensive function.
5718 
5719 #ifndef NDEBUG
5720  // AST quite reasonably asserts that it's working on a function
5721  // definition. We don't really have a way to tell it that we're
5722  // currently defining the function, so just lie to it in +Asserts
5723  // builds. This is an awful hack.
5724  FD->setLazyBody(1);
5725 #endif
5726 
5727  bool isC99Inline =
5729 
5730 #ifndef NDEBUG
5731  FD->setLazyBody(0);
5732 #endif
5733 
5734  return isC99Inline;
5735 }
5736 
5737 /// Determine whether a variable is extern "C" prior to attaching
5738 /// an initializer. We can't just call isExternC() here, because that
5739 /// will also compute and cache whether the declaration is externally
5740 /// visible, which might change when we attach the initializer.
5741 ///
5742 /// This can only be used if the declaration is known to not be a
5743 /// redeclaration of an internal linkage declaration.
5744 ///
5745 /// For instance:
5746 ///
5747 /// auto x = []{};
5748 ///
5749 /// Attaching the initializer here makes this declaration not externally
5750 /// visible, because its type has internal linkage.
5751 ///
5752 /// FIXME: This is a hack.
5753 template<typename T>
5754 static bool isIncompleteDeclExternC(Sema &S, const T *D) {
5755  if (S.getLangOpts().CPlusPlus) {
5756  // In C++, the overloadable attribute negates the effects of extern "C".
5757  if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
5758  return false;
5759 
5760  // So do CUDA's host/device attributes.
5761  if (S.getLangOpts().CUDA && (D->template hasAttr<CUDADeviceAttr>() ||
5762  D->template hasAttr<CUDAHostAttr>()))
5763  return false;
5764  }
5765  return D->isExternC();
5766 }
5767 
5768 static bool shouldConsiderLinkage(const VarDecl *VD) {
5769  const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
5770  if (DC->isFunctionOrMethod() || isa<OMPDeclareReductionDecl>(DC))
5771  return VD->hasExternalStorage();
5772  if (DC->isFileContext())
5773  return true;
5774  if (DC->isRecord())
5775  return false;
5776  llvm_unreachable("Unexpected context");
5777 }
5778 
5779 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
5780  const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
5781  if (DC->isFileContext() || DC->isFunctionOrMethod() ||
5782  isa<OMPDeclareReductionDecl>(DC))
5783  return true;
5784  if (DC->isRecord())
5785  return false;
5786  llvm_unreachable("Unexpected context");
5787 }
5788 
5789 static bool hasParsedAttr(Scope *S, const AttributeList *AttrList,
5791  for (const AttributeList *L = AttrList; L; L = L->getNext())
5792  if (L->getKind() == Kind)
5793  return true;
5794  return false;
5795 }
5796 
5797 static bool hasParsedAttr(Scope *S, const Declarator &PD,
5799  // Check decl attributes on the DeclSpec.
5801  return true;
5802 
5803  // Walk the declarator structure, checking decl attributes that were in a type
5804  // position to the decl itself.
5805  for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
5806  if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind))
5807  return true;
5808  }
5809 
5810  // Finally, check attributes on the decl itself.
5811  return hasParsedAttr(S, PD.getAttributes(), Kind);
5812 }
5813 
5814 /// Adjust the \c DeclContext for a function or variable that might be a
5815 /// function-local external declaration.
5817  if (!DC->isFunctionOrMethod())
5818  return false;
5819 
5820  // If this is a local extern function or variable declared within a function
5821  // template, don't add it into the enclosing namespace scope until it is
5822  // instantiated; it might have a dependent type right now.
5823  if (DC->isDependentContext())
5824  return true;
5825 
5826  // C++11 [basic.link]p7:
5827  // When a block scope declaration of an entity with linkage is not found to
5828  // refer to some other declaration, then that entity is a member of the
5829  // innermost enclosing namespace.
5830  //
5831  // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
5832  // semantically-enclosing namespace, not a lexically-enclosing one.
5833  while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
5834  DC = DC->getParent();
5835  return true;
5836 }
5837 
5838 /// \brief Returns true if given declaration has external C language linkage.
5839 static bool isDeclExternC(const Decl *D) {
5840  if (const auto *FD = dyn_cast<FunctionDecl>(D))
5841  return FD->isExternC();
5842  if (const auto *VD = dyn_cast<VarDecl>(D))
5843  return VD->isExternC();
5844 
5845  llvm_unreachable("Unknown type of decl!");
5846 }
5847 
5848 NamedDecl *
5851  MultiTemplateParamsArg TemplateParamLists,
5852  bool &AddToScope) {
5853  QualType R = TInfo->getType();
5854  DeclarationName Name = GetNameForDeclarator(D).getName();
5855 
5856  // OpenCL v2.0 s6.9.b - Image type can only be used as a function argument.
5857  // OpenCL v2.0 s6.13.16.1 - Pipe type can only be used as a function
5858  // argument.
5859  if (getLangOpts().OpenCL && (R->isImageType() || R->isPipeType())) {
5860  Diag(D.getIdentifierLoc(),
5861  diag::err_opencl_type_can_only_be_used_as_function_parameter)
5862  << R;
5863  D.setInvalidType();
5864  return nullptr;
5865  }
5866 
5869 
5870  // dllimport globals without explicit storage class are treated as extern. We
5871  // have to change the storage class this early to get the right DeclContext.
5872  if (SC == SC_None && !DC->isRecord() &&
5873  hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
5874  !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
5875  SC = SC_Extern;
5876 
5877  DeclContext *OriginalDC = DC;
5878  bool IsLocalExternDecl = SC == SC_Extern &&
5879  adjustContextForLocalExternDecl(DC);
5880 
5881  if (getLangOpts().OpenCL) {
5882  // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
5883  QualType NR = R;
5884  while (NR->isPointerType()) {
5885  if (NR->isFunctionPointerType()) {
5886  Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable);
5887  D.setInvalidType();
5888  break;
5889  }
5890  NR = NR->getPointeeType();
5891  }
5892 
5893  if (!getOpenCLOptions().cl_khr_fp16) {
5894  // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
5895  // half array type (unless the cl_khr_fp16 extension is enabled).
5897  Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
5898  D.setInvalidType();
5899  }
5900  }
5901  }
5902 
5903  if (SCSpec == DeclSpec::SCS_mutable) {
5904  // mutable can only appear on non-static class members, so it's always
5905  // an error here
5906  Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
5907  D.setInvalidType();
5908  SC = SC_None;
5909  }
5910 
5911  if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
5912  !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
5914  // In C++11, the 'register' storage class specifier is deprecated.
5915  // Suppress the warning in system macros, it's used in macros in some
5916  // popular C system headers, such as in glibc's htonl() macro.
5918  getLangOpts().CPlusPlus1z ? diag::ext_register_storage_class
5919  : diag::warn_deprecated_register)
5921  }
5922 
5923  IdentifierInfo *II = Name.getAsIdentifierInfo();
5924  if (!II) {
5925  Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
5926  << Name;
5927  return nullptr;
5928  }
5929 
5930  DiagnoseFunctionSpecifiers(D.getDeclSpec());
5931 
5932  if (!DC->isRecord() && S->getFnParent() == nullptr) {
5933  // C99 6.9p2: The storage-class specifiers auto and register shall not
5934  // appear in the declaration specifiers in an external declaration.
5935  // Global Register+Asm is a GNU extension we support.
5936  if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
5937  Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
5938  D.setInvalidType();
5939  }
5940  }
5941 
5942  if (getLangOpts().OpenCL) {
5943  // OpenCL v1.2 s6.9.b p4:
5944  // The sampler type cannot be used with the __local and __global address
5945  // space qualifiers.
5946  if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
5948  Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
5949  }
5950 
5951  // OpenCL 1.2 spec, p6.9 r:
5952  // The event type cannot be used to declare a program scope variable.
5953  // The event type cannot be used with the __local, __constant and __global
5954  // address space qualifiers.
5955  if (R->isEventT()) {
5956  if (S->getParent() == nullptr) {
5957  Diag(D.getLocStart(), diag::err_event_t_global_var);
5958  D.setInvalidType();
5959  }
5960 
5961  if (R.getAddressSpace()) {
5962  Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
5963  D.setInvalidType();
5964  }
5965  }
5966  }
5967 
5968  bool IsExplicitSpecialization = false;
5969  bool IsVariableTemplateSpecialization = false;
5970  bool IsPartialSpecialization = false;
5971  bool IsVariableTemplate = false;
5972  VarDecl *NewVD = nullptr;
5973  VarTemplateDecl *NewTemplate = nullptr;
5974  TemplateParameterList *TemplateParams = nullptr;
5975  if (!getLangOpts().CPlusPlus) {
5976  NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5977  D.getIdentifierLoc(), II,
5978  R, TInfo, SC);
5979 
5980  if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
5981  ParsingInitForAutoVars.insert(NewVD);
5982 
5983  if (D.isInvalidType())
5984  NewVD->setInvalidDecl();
5985  } else {
5986  bool Invalid = false;
5987 
5988  if (DC->isRecord() && !CurContext->isRecord()) {
5989  // This is an out-of-line definition of a static data member.
5990  switch (SC) {
5991  case SC_None:
5992  break;
5993  case SC_Static:
5995  diag::err_static_out_of_line)
5997  break;
5998  case SC_Auto:
5999  case SC_Register:
6000  case SC_Extern:
6001  // [dcl.stc] p2: The auto or register specifiers shall be applied only
6002  // to names of variables declared in a block or to function parameters.
6003  // [dcl.stc] p6: The extern specifier cannot be used in the declaration
6004  // of class members
6005 
6007  diag::err_storage_class_for_static_member)
6009  break;
6010  case SC_PrivateExtern:
6011  llvm_unreachable("C storage class in c++!");
6012  }
6013  }
6014 
6015  if (SC == SC_Static && CurContext->isRecord()) {
6016  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
6017  if (RD->isLocalClass())
6018  Diag(D.getIdentifierLoc(),
6019  diag::err_static_data_member_not_allowed_in_local_class)
6020  << Name << RD->getDeclName();
6021 
6022  // C++98 [class.union]p1: If a union contains a static data member,
6023  // the program is ill-formed. C++11 drops this restriction.
6024  if (RD->isUnion())
6025  Diag(D.getIdentifierLoc(),
6026  getLangOpts().CPlusPlus11
6027  ? diag::warn_cxx98_compat_static_data_member_in_union
6028  : diag::ext_static_data_member_in_union) << Name;
6029  // We conservatively disallow static data members in anonymous structs.
6030  else if (!RD->getDeclName())
6031  Diag(D.getIdentifierLoc(),
6032  diag::err_static_data_member_not_allowed_in_anon_struct)
6033  << Name << RD->isUnion();
6034  }
6035  }
6036 
6037  // Match up the template parameter lists with the scope specifier, then
6038  // determine whether we have a template or a template specialization.
6039  TemplateParams = MatchTemplateParametersToScopeSpecifier(
6041  D.getCXXScopeSpec(),
6043  ? D.getName().TemplateId
6044  : nullptr,
6045  TemplateParamLists,
6046  /*never a friend*/ false, IsExplicitSpecialization, Invalid);
6047 
6048  if (TemplateParams) {
6049  if (!TemplateParams->size() &&
6051  // There is an extraneous 'template<>' for this variable. Complain
6052  // about it, but allow the declaration of the variable.
6053  Diag(TemplateParams->getTemplateLoc(),
6054  diag::err_template_variable_noparams)
6055  << II
6056  << SourceRange(TemplateParams->getTemplateLoc(),
6057  TemplateParams->getRAngleLoc());
6058  TemplateParams = nullptr;
6059  } else {
6061  // This is an explicit specialization or a partial specialization.
6062  // FIXME: Check that we can declare a specialization here.
6063  IsVariableTemplateSpecialization = true;
6064  IsPartialSpecialization = TemplateParams->size() > 0;
6065  } else { // if (TemplateParams->size() > 0)
6066  // This is a template declaration.
6067  IsVariableTemplate = true;
6068 
6069  // Check that we can declare a template here.
6070  if (CheckTemplateDeclScope(S, TemplateParams))
6071  return nullptr;
6072 
6073  // Only C++1y supports variable templates (N3651).
6074  Diag(D.getIdentifierLoc(),
6075  getLangOpts().CPlusPlus14
6076  ? diag::warn_cxx11_compat_variable_template
6077  : diag::ext_variable_template);
6078  }
6079  }
6080  } else {
6081  assert(
6082  (Invalid || D.getName().getKind() != UnqualifiedId::IK_TemplateId) &&
6083  "should have a 'template<>' for this decl");
6084  }
6085 
6086  if (IsVariableTemplateSpecialization) {
6087  SourceLocation TemplateKWLoc =
6088  TemplateParamLists.size() > 0
6089  ? TemplateParamLists[0]->getTemplateLoc()
6090  : SourceLocation();
6091  DeclResult Res = ActOnVarTemplateSpecialization(
6092  S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
6093  IsPartialSpecialization);
6094  if (Res.isInvalid())
6095  return nullptr;
6096  NewVD = cast<VarDecl>(Res.get());
6097  AddToScope = false;
6098  } else
6099  NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
6100  D.getIdentifierLoc(), II, R, TInfo, SC);
6101 
6102  // If this is supposed to be a variable template, create it as such.
6103  if (IsVariableTemplate) {
6104  NewTemplate =
6106  TemplateParams, NewVD);
6107  NewVD->setDescribedVarTemplate(NewTemplate);
6108  }
6109 
6110  // If this decl has an auto type in need of deduction, make a note of the
6111  // Decl so we can diagnose uses of it in its own initializer.
6112  if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
6113  ParsingInitForAutoVars.insert(NewVD);
6114 
6115  if (D.isInvalidType() || Invalid) {
6116  NewVD->setInvalidDecl();
6117  if (NewTemplate)
6118  NewTemplate->setInvalidDecl();
6119  }
6120 
6121  SetNestedNameSpecifier(NewVD, D);
6122 
6123  // If we have any template parameter lists that don't directly belong to
6124  // the variable (matching the scope specifier), store them.
6125  unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
6126  if (TemplateParamLists.size() > VDTemplateParamLists)
6128  Context, TemplateParamLists.drop_back(VDTemplateParamLists));
6129 
6130  if (D.getDeclSpec().isConstexprSpecified()) {
6131  NewVD->setConstexpr(true);
6132  // C++1z [dcl.spec.constexpr]p1:
6133  // A static data member declared with the constexpr specifier is
6134  // implicitly an inline variable.
6135  if (NewVD->isStaticDataMember() && getLangOpts().CPlusPlus1z)
6136  NewVD->setImplicitlyInline();
6137  }
6138 
6139  if (D.getDeclSpec().isConceptSpecified()) {
6140  if (VarTemplateDecl *VTD = NewVD->getDescribedVarTemplate())
6141  VTD->setConcept();
6142 
6143  // C++ Concepts TS [dcl.spec.concept]p2: A concept definition shall not
6144  // be declared with the thread_local, inline, friend, or constexpr
6145  // specifiers, [...]
6148  diag::err_concept_decl_invalid_specifiers)
6149  << 0 << 0;
6150  NewVD->setInvalidDecl(true);
6151  }
6152 
6153  if (D.getDeclSpec().isConstexprSpecified()) {
6155  diag::err_concept_decl_invalid_specifiers)
6156  << 0 << 3;
6157  NewVD->setInvalidDecl(true);
6158  }
6159 
6160  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
6161  // applied only to the definition of a function template or variable
6162  // template, declared in namespace scope.
6163  if (IsVariableTemplateSpecialization) {
6165  diag::err_concept_specified_specialization)
6166  << (IsPartialSpecialization ? 2 : 1);
6167  }
6168 
6169  // C++ Concepts TS [dcl.spec.concept]p6: A variable concept has the
6170  // following restrictions:
6171  // - The declared type shall have the type bool.
6172  if (!Context.hasSameType(NewVD->getType(), Context.BoolTy) &&
6173  !NewVD->isInvalidDecl()) {
6174  Diag(D.getIdentifierLoc(), diag::err_variable_concept_bool_decl);
6175  NewVD->setInvalidDecl(true);
6176  }
6177  }
6178  }
6179 
6180  if (D.getDeclSpec().isInlineSpecified()) {
6181  if (!getLangOpts().CPlusPlus) {
6182  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
6183  << 0;
6184  } else if (CurContext->isFunctionOrMethod()) {
6185  // 'inline' is not allowed on block scope variable declaration.
6187  diag::err_inline_declaration_block_scope) << Name
6189  } else {
6191  getLangOpts().CPlusPlus1z ? diag::warn_cxx14_compat_inline_variable
6192  : diag::ext_inline_variable);
6193  NewVD->setInlineSpecified();
6194  }
6195  }
6196 
6197  // Set the lexical context. If the declarator has a C++ scope specifier, the
6198  // lexical context will be different from the semantic context.
6199  NewVD->setLexicalDeclContext(CurContext);
6200  if (NewTemplate)
6201  NewTemplate->setLexicalDeclContext(CurContext);
6202 
6203  if (IsLocalExternDecl)
6204  NewVD->setLocalExternDecl();
6205 
6206  bool EmitTLSUnsupportedError = false;
6208  // C++11 [dcl.stc]p4:
6209  // When thread_local is applied to a variable of block scope the
6210  // storage-class-specifier static is implied if it does not appear
6211  // explicitly.
6212  // Core issue: 'static' is not implied if the variable is declared
6213  // 'extern'.
6214  if (NewVD->hasLocalStorage() &&
6215  (SCSpec != DeclSpec::SCS_unspecified ||
6216  TSCS != DeclSpec::TSCS_thread_local ||
6217  !DC->isFunctionOrMethod()))
6219  diag::err_thread_non_global)
6220  << DeclSpec::getSpecifierName(TSCS);
6221  else if (!Context.getTargetInfo().isTLSSupported()) {
6222  if (getLangOpts().CUDA) {
6223  // Postpone error emission until we've collected attributes required to
6224  // figure out whether it's a host or device variable and whether the
6225  // error should be ignored.
6226  EmitTLSUnsupportedError = true;
6227  // We still need to mark the variable as TLS so it shows up in AST with
6228  // proper storage class for other tools to use even if we're not going
6229  // to emit any code for it.
6230  NewVD->setTSCSpec(TSCS);
6231  } else
6233  diag::err_thread_unsupported);
6234  } else
6235  NewVD->setTSCSpec(TSCS);
6236  }
6237 
6238  // C99 6.7.4p3
6239  // An inline definition of a function with external linkage shall
6240  // not contain a definition of a modifiable object with static or
6241  // thread storage duration...
6242  // We only apply this when the function is required to be defined
6243  // elsewhere, i.e. when the function is not 'extern inline'. Note
6244  // that a local variable with thread storage duration still has to
6245  // be marked 'static'. Also note that it's possible to get these
6246  // semantics in C++ using __attribute__((gnu_inline)).
6247  if (SC == SC_Static && S->getFnParent() != nullptr &&
6248  !NewVD->getType().isConstQualified()) {
6249  FunctionDecl *CurFD = getCurFunctionDecl();
6250  if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
6252  diag::warn_static_local_in_extern_inline);
6253  MaybeSuggestAddingStaticToDecl(CurFD);
6254  }
6255  }
6256 
6258  if (IsVariableTemplateSpecialization)
6259  Diag(NewVD->getLocation(), diag::err_module_private_specialization)
6260  << (IsPartialSpecialization ? 1 : 0)
6263  else if (IsExplicitSpecialization)
6264  Diag(NewVD->getLocation(), diag::err_module_private_specialization)
6265  << 2
6267  else if (NewVD->hasLocalStorage())
6268  Diag(NewVD->getLocation(), diag::err_module_private_local)
6269  << 0 << NewVD->getDeclName()
6272  else {
6273  NewVD->setModulePrivate();
6274  if (NewTemplate)
6275  NewTemplate->setModulePrivate();
6276  }
6277  }
6278 
6279  // Handle attributes prior to checking for duplicates in MergeVarDecl
6280  ProcessDeclAttributes(S, NewVD, D);
6281 
6282  if (getLangOpts().CUDA) {
6283  if (EmitTLSUnsupportedError && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD))
6285  diag::err_thread_unsupported);
6286  // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
6287  // storage [duration]."
6288  if (SC == SC_None && S->getFnParent() != nullptr &&
6289  (NewVD->hasAttr<CUDASharedAttr>() ||
6290  NewVD->hasAttr<CUDAConstantAttr>())) {
6291  NewVD->setStorageClass(SC_Static);
6292  }
6293  }
6294 
6295  // Ensure that dllimport globals without explicit storage class are treated as
6296  // extern. The storage class is set above using parsed attributes. Now we can
6297  // check the VarDecl itself.
6298  assert(!NewVD->hasAttr<DLLImportAttr>() ||
6299  NewVD->getAttr<DLLImportAttr>()->isInherited() ||
6300  NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
6301 
6302  // In auto-retain/release, infer strong retension for variables of
6303  // retainable type.
6304  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
6305  NewVD->setInvalidDecl();
6306 
6307  // Handle GNU asm-label extension (encoded as an attribute).
6308  if (Expr *E = (Expr*)D.getAsmLabel()) {
6309  // The parser guarantees this is a string.
6310  StringLiteral *SE = cast<StringLiteral>(E);
6311  StringRef Label = SE->getString();
6312  if (S->getFnParent() != nullptr) {
6313  switch (SC) {
6314  case SC_None:
6315  case SC_Auto:
6316  Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
6317  break;
6318  case SC_Register:
6319  // Local Named register
6321  DeclAttrsMatchCUDAMode(getLangOpts(), getCurFunctionDecl()))
6322  Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
6323  break;
6324  case SC_Static:
6325  case SC_Extern:
6326  case SC_PrivateExtern:
6327  break;
6328  }
6329  } else if (SC == SC_Register) {
6330  // Global Named register
6331  if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) {
6332  const auto &TI = Context.getTargetInfo();
6333  bool HasSizeMismatch;
6334 
6335  if (!TI.isValidGCCRegisterName(Label))
6336  Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
6337  else if (!TI.validateGlobalRegisterVariable(Label,
6338  Context.getTypeSize(R),
6339  HasSizeMismatch))
6340  Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) << Label;
6341  else if (HasSizeMismatch)
6342  Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) << Label;
6343  }
6344 
6345  if (!R->isIntegralType(Context) && !R->isPointerType()) {
6346  Diag(D.getLocStart(), diag::err_asm_bad_register_type);
6347  NewVD->setInvalidDecl(true);
6348  }
6349  }
6350 
6351  NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
6352  Context, Label, 0));
6353  } else if (!ExtnameUndeclaredIdentifiers.empty()) {
6355  ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
6356  if (I != ExtnameUndeclaredIdentifiers.end()) {
6357  if (isDeclExternC(NewVD)) {
6358  NewVD->addAttr(I->second);
6359  ExtnameUndeclaredIdentifiers.erase(I);
6360  } else
6361  Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied)
6362  << /*Variable*/1 << NewVD;
6363  }
6364  }
6365 
6366  // Diagnose shadowed variables before filtering for scope.
6367  if (D.getCXXScopeSpec().isEmpty())
6368  CheckShadow(S, NewVD, Previous);
6369 
6370  // Don't consider existing declarations that are in a different
6371  // scope and are out-of-semantic-context declarations (if the new
6372  // declaration has linkage).
6373  FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
6374  D.getCXXScopeSpec().isNotEmpty() ||
6375  IsExplicitSpecialization ||
6376  IsVariableTemplateSpecialization);
6377 
6378  // Check whether the previous declaration is in the same block scope. This
6379  // affects whether we merge types with it, per C++11 [dcl.array]p3.
6380  if (getLangOpts().CPlusPlus &&
6381  NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
6383  Previous.isSingleResult() && !Previous.isShadowed() &&
6384  isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
6385 
6386  if (!getLangOpts().CPlusPlus) {
6387  D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6388  } else {
6389  // If this is an explicit specialization of a static data member, check it.
6390  if (IsExplicitSpecialization && !NewVD->isInvalidDecl() &&
6391  CheckMemberSpecialization(NewVD, Previous))
6392  NewVD->setInvalidDecl();
6393 
6394  // Merge the decl with the existing one if appropriate.
6395  if (!Previous.empty()) {
6396  if (Previous.isSingleResult() &&
6397  isa<FieldDecl>(Previous.getFoundDecl()) &&
6398  D.getCXXScopeSpec().isSet()) {
6399  // The user tried to define a non-static data member
6400  // out-of-line (C++ [dcl.meaning]p1).
6401  Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
6402  << D.getCXXScopeSpec().getRange();
6403  Previous.clear();
6404  NewVD->setInvalidDecl();
6405  }
6406  } else if (D.getCXXScopeSpec().isSet()) {
6407  // No previous declaration in the qualifying scope.
6408  Diag(D.getIdentifierLoc(), diag::err_no_member)
6409  << Name << computeDeclContext(D.getCXXScopeSpec(), true)
6410  << D.getCXXScopeSpec().getRange();
6411  NewVD->setInvalidDecl();
6412  }
6413 
6414  if (!IsVariableTemplateSpecialization)
6415  D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6416 
6417  // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare [...]
6418  // an explicit specialization (14.8.3) or a partial specialization of a
6419  // concept definition.
6420  if (IsVariableTemplateSpecialization &&
6421  !D.getDeclSpec().isConceptSpecified() && !Previous.empty() &&
6422  Previous.isSingleResult()) {
6423  NamedDecl *PreviousDecl = Previous.getFoundDecl();
6424  if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(PreviousDecl)) {
6425  if (VarTmpl->isConcept()) {
6426  Diag(NewVD->getLocation(), diag::err_concept_specialized)
6427  << 1 /*variable*/
6428  << (IsPartialSpecialization ? 2 /*partially specialized*/
6429  : 1 /*explicitly specialized*/);
6430  Diag(VarTmpl->getLocation(), diag::note_previous_declaration);
6431  NewVD->setInvalidDecl();
6432  }
6433  }
6434  }
6435 
6436  if (NewTemplate) {
6437  VarTemplateDecl *PrevVarTemplate =
6438  NewVD->getPreviousDecl()
6440  : nullptr;
6441 
6442  // Check the template parameter list of this declaration, possibly
6443  // merging in the template parameter list from the previous variable
6444  // template declaration.
6445  if (CheckTemplateParameterList(
6446  TemplateParams,
6447  PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
6448  : nullptr,
6449  (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
6450  DC->isDependentContext())
6451  ? TPC_ClassTemplateMember
6452  : TPC_VarTemplate))
6453  NewVD->setInvalidDecl();
6454 
6455  // If we are providing an explicit specialization of a static variable
6456  // template, make a note of that.
6457  if (PrevVarTemplate &&
6458  PrevVarTemplate->getInstantiatedFromMemberTemplate())
6459  PrevVarTemplate->setMemberSpecialization();
6460  }
6461  }
6462 
6463  ProcessPragmaWeak(S, NewVD);
6464 
6465  // If this is the first declaration of an extern C variable, update
6466  // the map of such variables.
6467  if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
6468  isIncompleteDeclExternC(*this, NewVD))
6469  RegisterLocallyScopedExternCDecl(NewVD, S);
6470 
6471  if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
6472  Decl *ManglingContextDecl;
6473  if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
6474  NewVD->getDeclContext(), ManglingContextDecl)) {
6476  NewVD, MCtx->getManglingNumber(
6477  NewVD, getMSManglingNumber(getLangOpts(), S)));
6478  Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
6479  }
6480  }
6481 
6482  // Special handling of variable named 'main'.
6483  if (Name.isIdentifier() && Name.getAsIdentifierInfo()->isStr("main") &&
6484  NewVD->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
6485  !getLangOpts().Freestanding && !NewVD->getDescribedVarTemplate()) {
6486 
6487  // C++ [basic.start.main]p3
6488  // A program that declares a variable main at global scope is ill-formed.
6489  if (getLangOpts().CPlusPlus)
6490  Diag(D.getLocStart(), diag::err_main_global_variable);
6491 
6492  // In C, and external-linkage variable named main results in undefined
6493  // behavior.
6494  else if (NewVD->hasExternalFormalLinkage())
6495  Diag(D.getLocStart(), diag::warn_main_redefined);
6496  }
6497 
6498  if (D.isRedeclaration() && !Previous.empty()) {
6500  *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD,
6501  IsExplicitSpecialization, D.isFunctionDefinition());
6502  }
6503 
6504  if (NewTemplate) {
6505  if (NewVD->isInvalidDecl())
6506  NewTemplate->setInvalidDecl();
6507  ActOnDocumentableDecl(NewTemplate);
6508  return NewTemplate;
6509  }
6510 
6511  return NewVD;
6512 }
6513 
6514 /// Enum describing the %select options in diag::warn_decl_shadow.
6516 
6517 /// Determine what kind of declaration we're shadowing.
6519  const DeclContext *OldDC) {
6520  if (isa<RecordDecl>(OldDC))
6521  return isa<FieldDecl>(ShadowedDecl) ? SDK_Field : SDK_StaticMember;
6522  return OldDC->isFileContext() ? SDK_Global : SDK_Local;
6523 }
6524 
6525 /// \brief Diagnose variable or built-in function shadowing. Implements
6526 /// -Wshadow.
6527 ///
6528 /// This method is called whenever a VarDecl is added to a "useful"
6529 /// scope.
6530 ///
6531 /// \param S the scope in which the shadowing name is being declared
6532 /// \param R the lookup of the name
6533 ///
6535  // Return if warning is ignored.
6536  if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()))
6537  return;
6538 
6539  // Don't diagnose declarations at file scope.
6540  if (D->hasGlobalStorage())
6541  return;
6542 
6543  DeclContext *NewDC = D->getDeclContext();
6544 
6545  // Only diagnose if we're shadowing an unambiguous field or variable.
6547  return;
6548 
6549  NamedDecl* ShadowedDecl = R.getFoundDecl();
6550  if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
6551  return;
6552 
6553  if (FieldDecl *FD = dyn_cast<FieldDecl>(ShadowedDecl)) {
6554  // Fields are not shadowed by variables in C++ static methods.
6555  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
6556  if (MD->isStatic())
6557  return;
6558 
6559  // Fields shadowed by constructor parameters are a special case. Usually
6560  // the constructor initializes the field with the parameter.
6561  if (isa<CXXConstructorDecl>(NewDC) && isa<ParmVarDecl>(D)) {
6562  // Remember that this was shadowed so we can either warn about its
6563  // modification or its existence depending on warning settings.
6564  D = D->getCanonicalDecl();
6565  ShadowingDecls.insert({D, FD});
6566  return;
6567  }
6568  }
6569 
6570  if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
6571  if (shadowedVar->isExternC()) {
6572  // For shadowing external vars, make sure that we point to the global
6573  // declaration, not a locally scoped extern declaration.
6574  for (auto I : shadowedVar->redecls())
6575  if (I->isFileVarDecl()) {
6576  ShadowedDecl = I;
6577  break;
6578  }
6579  }
6580 
6581  DeclContext *OldDC = ShadowedDecl->getDeclContext();
6582 
6583  // Only warn about certain kinds of shadowing for class members.
6584  if (NewDC && NewDC->isRecord()) {
6585  // In particular, don't warn about shadowing non-class members.
6586  if (!OldDC->isRecord())
6587  return;
6588 
6589  // TODO: should we warn about static data members shadowing
6590  // static data members from base classes?
6591 
6592  // TODO: don't diagnose for inaccessible shadowed members.
6593  // This is hard to do perfectly because we might friend the
6594  // shadowing context, but that's just a false negative.
6595  }
6596 
6597 
6599 
6600  // Emit warning and note.
6601  if (getSourceManager().isInSystemMacro(R.getNameLoc()))
6602  return;
6603  ShadowedDeclKind Kind = computeShadowedDeclKind(ShadowedDecl, OldDC);
6604  Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
6605  Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
6606 }
6607 
6608 /// \brief Check -Wshadow without the advantage of a previous lookup.
6610  if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
6611  return;
6612 
6613  LookupResult R(*this, D->getDeclName(), D->getLocation(),
6615  LookupName(R, S);
6616  CheckShadow(S, D, R);
6617 }
6618 
6619 /// Check if 'E', which is an expression that is about to be modified, refers
6620 /// to a constructor parameter that shadows a field.
6622  // Quickly ignore expressions that can't be shadowing ctor parameters.
6623  if (!getLangOpts().CPlusPlus || ShadowingDecls.empty())
6624  return;
6625  E = E->IgnoreParenImpCasts();
6626  auto *DRE = dyn_cast<DeclRefExpr>(E);
6627  if (!DRE)
6628  return;
6629  const NamedDecl *D = cast<NamedDecl>(DRE->getDecl()->getCanonicalDecl());
6630  auto I = ShadowingDecls.find(D);
6631  if (I == ShadowingDecls.end())
6632  return;
6633  const NamedDecl *ShadowedDecl = I->second;
6634  const DeclContext *OldDC = ShadowedDecl->getDeclContext();
6635  Diag(Loc, diag::warn_modifying_shadowing_decl) << D << OldDC;
6636  Diag(D->getLocation(), diag::note_var_declared_here) << D;
6637  Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
6638 
6639  // Avoid issuing multiple warnings about the same decl.
6640  ShadowingDecls.erase(I);
6641 }
6642 
6643 /// Check for conflict between this global or extern "C" declaration and
6644 /// previous global or extern "C" declarations. This is only used in C++.
6645 template<typename T>
6647  Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
6648  assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
6649  NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
6650 
6651  if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
6652  // The common case: this global doesn't conflict with any extern "C"
6653  // declaration.
6654  return false;
6655  }
6656 
6657  if (Prev) {
6658  if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
6659  // Both the old and new declarations have C language linkage. This is a
6660  // redeclaration.
6661  Previous.clear();
6662  Previous.addDecl(Prev);
6663  return true;
6664  }
6665 
6666  // This is a global, non-extern "C" declaration, and there is a previous
6667  // non-global extern "C" declaration. Diagnose if this is a variable
6668  // declaration.
6669  if (!isa<VarDecl>(ND))
6670  return false;
6671  } else {
6672  // The declaration is extern "C". Check for any declaration in the
6673  // translation unit which might conflict.
6674  if (IsGlobal) {
6675  // We have already performed the lookup into the translation unit.
6676  IsGlobal = false;
6677  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6678  I != E; ++I) {
6679  if (isa<VarDecl>(*I)) {
6680  Prev = *I;
6681  break;
6682  }
6683  }
6684  } else {
6686  S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
6687  for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
6688  I != E; ++I) {
6689  if (isa<VarDecl>(*I)) {
6690  Prev = *I;
6691  break;
6692  }
6693  // FIXME: If we have any other entity with this name in global scope,
6694  // the declaration is ill-formed, but that is a defect: it breaks the
6695  // 'stat' hack, for instance. Only variables can have mangled name
6696  // clashes with extern "C" declarations, so only they deserve a
6697  // diagnostic.
6698  }
6699  }
6700 
6701  if (!Prev)
6702  return false;
6703  }
6704 
6705  // Use the first declaration's location to ensure we point at something which
6706  // is lexically inside an extern "C" linkage-spec.
6707  assert(Prev && "should have found a previous declaration to diagnose");
6708  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
6709  Prev = FD->getFirstDecl();
6710  else
6711  Prev = cast<VarDecl>(Prev)->getFirstDecl();
6712 
6713  S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
6714  << IsGlobal << ND;
6715  S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
6716  << IsGlobal;
6717  return false;
6718 }
6719 
6720 /// Apply special rules for handling extern "C" declarations. Returns \c true
6721 /// if we have found that this is a redeclaration of some prior entity.
6722 ///
6723 /// Per C++ [dcl.link]p6:
6724 /// Two declarations [for a function or variable] with C language linkage
6725 /// with the same name that appear in different scopes refer to the same
6726 /// [entity]. An entity with C language linkage shall not be declared with
6727 /// the same name as an entity in global scope.
6728 template<typename T>
6731  if (!S.getLangOpts().CPlusPlus) {
6732  // In C, when declaring a global variable, look for a corresponding 'extern'
6733  // variable declared in function scope. We don't need this in C++, because
6734  // we find local extern decls in the surrounding file-scope DeclContext.
6735  if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
6736  if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
6737  Previous.clear();
6738  Previous.addDecl(Prev);
6739  return true;
6740  }
6741  }
6742  return false;
6743  }
6744 
6745  // A declaration in the translation unit can conflict with an extern "C"
6746  // declaration.
6747  if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
6748  return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
6749 
6750  // An extern "C" declaration can conflict with a declaration in the
6751  // translation unit or can be a redeclaration of an extern "C" declaration
6752  // in another scope.
6753  if (isIncompleteDeclExternC(S,ND))
6754  return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
6755 
6756  // Neither global nor extern "C": nothing to do.
6757  return false;
6758 }
6759 
6761  // If the decl is already known invalid, don't check it.
6762  if (NewVD->isInvalidDecl())
6763  return;
6764 
6765  TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
6766  QualType T = TInfo->getType();
6767 
6768  // Defer checking an 'auto' type until its initializer is attached.
6769  if (T->isUndeducedType())
6770  return;
6771 
6772  if (NewVD->hasAttrs())
6773  CheckAlignasUnderalignment(NewVD);
6774 
6775  if (T->isObjCObjectType()) {
6776  Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
6777  << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
6779  NewVD->setType(T);
6780  }
6781 
6782  // Emit an error if an address space was applied to decl with local storage.
6783  // This includes arrays of objects with address space qualifiers, but not
6784  // automatic variables that point to other address spaces.
6785  // ISO/IEC TR 18037 S5.1.2
6786  if (!getLangOpts().OpenCL
6787  && NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
6788  Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
6789  NewVD->setInvalidDecl();
6790  return;
6791  }
6792 
6793  // OpenCL v1.2 s6.8 - The static qualifier is valid only in program
6794  // scope.
6795  if (getLangOpts().OpenCLVersion == 120 &&
6796  !getOpenCLOptions().cl_clang_storage_class_specifiers &&
6797  NewVD->isStaticLocal()) {
6798  Diag(NewVD->getLocation(), diag::err_static_function_scope);
6799  NewVD->setInvalidDecl();
6800  return;
6801  }
6802 
6803  if (getLangOpts().OpenCL) {
6804  // OpenCL v2.0 s6.12.5 - The __block storage type is not supported.
6805  if (NewVD->hasAttr<BlocksAttr>()) {
6806  Diag(NewVD->getLocation(), diag::err_opencl_block_storage_type);
6807  return;
6808  }
6809 
6810  if (T->isBlockPointerType()) {
6811  // OpenCL v2.0 s6.12.5 - Any block declaration must be const qualified and
6812  // can't use 'extern' storage class.
6813  if (!T.isConstQualified()) {
6814  Diag(NewVD->getLocation(), diag::err_opencl_invalid_block_declaration)
6815  << 0 /*const*/;
6816  NewVD->setInvalidDecl();
6817  return;
6818  }
6819  if (NewVD->hasExternalStorage()) {
6820  Diag(NewVD->getLocation(), diag::err_opencl_extern_block_declaration);
6821  NewVD->setInvalidDecl();
6822  return;
6823  }
6824  // OpenCL v2.0 s6.12.5 - Blocks with variadic arguments are not supported.
6825  // TODO: this check is not enough as it doesn't diagnose the typedef
6826  const BlockPointerType *BlkTy = T->getAs<BlockPointerType>();
6827  const FunctionProtoType *FTy =
6828  BlkTy->getPointeeType()->getAs<FunctionProtoType>();
6829  if (FTy && FTy->isVariadic()) {
6830  Diag(NewVD->getLocation(), diag::err_opencl_block_proto_variadic)
6831  << T << NewVD->getSourceRange();
6832  NewVD->setInvalidDecl();
6833  return;
6834  }
6835  }
6836  // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
6837  // __constant address space.
6838  // OpenCL v2.0 s6.5.1 - Variables defined at program scope and static
6839  // variables inside a function can also be declared in the global
6840  // address space.
6841  if (NewVD->isFileVarDecl() || NewVD->isStaticLocal() ||
6842  NewVD->hasExternalStorage()) {
6843  if (!T->isSamplerT() &&
6846  getLangOpts().OpenCLVersion == 200))) {
6847  int Scope = NewVD->isStaticLocal() | NewVD->hasExternalStorage() << 1;
6848  if (getLangOpts().OpenCLVersion == 200)
6849  Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
6850  << Scope << "global or constant";
6851  else
6852  Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
6853  << Scope << "constant";
6854  NewVD->setInvalidDecl();
6855  return;
6856  }
6857  } else {
6859  Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
6860  << 1 /*is any function*/ << "global";
6861  NewVD->setInvalidDecl();
6862  return;
6863  }
6864  // OpenCL v1.1 s6.5.2 and s6.5.3 no local or constant variables
6865  // in functions.
6868  FunctionDecl *FD = getCurFunctionDecl();
6869  if (FD && !FD->hasAttr<OpenCLKernelAttr>()) {
6871  Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
6872  << 0 /*non-kernel only*/ << "constant";
6873  else
6874  Diag(NewVD->getLocation(), diag::err_opencl_function_variable)
6875  << 0 /*non-kernel only*/ << "local";
6876  NewVD->setInvalidDecl();
6877  return;
6878  }
6879  }
6880  }
6881  }
6882 
6883  if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
6884  && !NewVD->hasAttr<BlocksAttr>()) {
6885  if (getLangOpts().getGC() != LangOptions::NonGC)
6886  Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
6887  else {
6888  assert(!getLangOpts().ObjCAutoRefCount);
6889  Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
6890  }
6891  }
6892 
6893  bool isVM = T->isVariablyModifiedType();
6894  if (isVM || NewVD->hasAttr<CleanupAttr>() ||
6895  NewVD->hasAttr<BlocksAttr>())
6896  getCurFunction()->setHasBranchProtectedScope();
6897 
6898  if ((isVM && NewVD->hasLinkage()) ||
6899  (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
6900  bool SizeIsNegative;
6901  llvm::APSInt Oversized;
6902  TypeSourceInfo *FixedTInfo =
6904  SizeIsNegative, Oversized);
6905  if (!FixedTInfo && T->isVariableArrayType()) {
6907  // FIXME: This won't give the correct result for
6908  // int a[10][n];
6909  SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
6910 
6911  if (NewVD->isFileVarDecl())
6912  Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
6913  << SizeRange;
6914  else if (NewVD->isStaticLocal())
6915  Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
6916  << SizeRange;
6917  else
6918  Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
6919  << SizeRange;
6920  NewVD->setInvalidDecl();
6921  return;
6922  }
6923 
6924  if (!FixedTInfo) {
6925  if (NewVD->isFileVarDecl())
6926  Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
6927  else
6928  Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
6929  NewVD->setInvalidDecl();
6930  return;
6931  }
6932 
6933  Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
6934  NewVD->setType(FixedTInfo->getType());
6935  NewVD->setTypeSourceInfo(FixedTInfo);
6936  }
6937 
6938  if (T->isVoidType()) {
6939  // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
6940  // of objects and functions.
6941  if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
6942  Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
6943  << T;
6944  NewVD->setInvalidDecl();
6945  return;
6946  }
6947  }
6948 
6949  if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
6950  Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
6951  NewVD->setInvalidDecl();
6952  return;
6953  }
6954 
6955  if (isVM && NewVD->hasAttr<BlocksAttr>()) {
6956  Diag(NewVD->getLocation(), diag::err_block_on_vm);
6957  NewVD->setInvalidDecl();
6958  return;
6959  }
6960 
6961  if (NewVD->isConstexpr() && !T->isDependentType() &&
6962  RequireLiteralType(NewVD->getLocation(), T,
6963  diag::err_constexpr_var_non_literal)) {
6964  NewVD->setInvalidDecl();
6965  return;
6966  }
6967 }
6968 
6969 /// \brief Perform semantic checking on a newly-created variable
6970 /// declaration.
6971 ///
6972 /// This routine performs all of the type-checking required for a
6973 /// variable declaration once it has been built. It is used both to
6974 /// check variables after they have been parsed and their declarators
6975 /// have been translated into a declaration, and to check variables
6976 /// that have been instantiated from a template.
6977 ///
6978 /// Sets NewVD->isInvalidDecl() if an error was encountered.
6979 ///
6980 /// Returns true if the variable declaration is a redeclaration.
6982  CheckVariableDeclarationType(NewVD);
6983 
6984  // If the decl is already known invalid, don't check it.
6985  if (NewVD->isInvalidDecl())
6986  return false;
6987 
6988  // If we did not find anything by this name, look for a non-visible
6989  // extern "C" declaration with the same name.
6990  if (Previous.empty() &&
6991  checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
6992  Previous.setShadowed();
6993 
6994  if (!Previous.empty()) {
6995  MergeVarDecl(NewVD, Previous);
6996  return true;
6997  }
6998  return false;
6999 }
7000 
7001 namespace {
7002 struct FindOverriddenMethod {
7003  Sema *S;
7004  CXXMethodDecl *Method;
7005 
7006  /// Member lookup function that determines whether a given C++
7007  /// method overrides a method in a base class, to be used with
7008  /// CXXRecordDecl::lookupInBases().
7009  bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
7010  RecordDecl *BaseRecord =
7011  Specifier->getType()->getAs<RecordType>()->getDecl();
7012 
7013  DeclarationName Name = Method->getDeclName();
7014 
7015  // FIXME: Do we care about other names here too?
7017  // We really want to find the base class destructor here.
7018  QualType T = S->Context.getTypeDeclType(BaseRecord);
7020 
7022  }
7023 
7024  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
7025  Path.Decls = Path.Decls.slice(1)) {
7026  NamedDecl *D = Path.Decls.front();
7027  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
7028  if (MD->isVirtual() && !S->IsOverload(Method, MD, false))
7029  return true;
7030  }
7031  }
7032 
7033  return false;
7034  }
7035 };
7036 
7037 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
7038 } // end anonymous namespace
7039 
7040 /// \brief Report an error regarding overriding, along with any relevant
7041 /// overriden methods.
7042 ///
7043 /// \param DiagID the primary error to report.
7044 /// \param MD the overriding method.
7045 /// \param OEK which overrides to include as notes.
7046 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
7047  OverrideErrorKind OEK = OEK_All) {
7048  S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
7050  E = MD->end_overridden_methods();
7051  I != E; ++I) {
7052  // This check (& the OEK parameter) could be replaced by a predicate, but
7053  // without lambdas that would be overkill. This is still nicer than writing
7054  // out the diag loop 3 times.
7055  if ((OEK == OEK_All) ||
7056  (OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
7057  (OEK == OEK_Deleted && (*I)->isDeleted()))
7058  S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
7059  }
7060 }
7061 
7062 /// AddOverriddenMethods - See if a method overrides any in the base classes,
7063 /// and if so, check that it's a valid override and remember it.
7065  // Look for methods in base classes that this method might override.
7066  CXXBasePaths Paths;
7067  FindOverriddenMethod FOM;
7068  FOM.Method = MD;
7069  FOM.S = this;
7070  bool hasDeletedOverridenMethods = false;
7071  bool hasNonDeletedOverridenMethods = false;
7072  bool AddedAny = false;
7073  if (DC->lookupInBases(FOM, Paths)) {
7074  for (auto *I : Paths.found_decls()) {
7075  if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
7076  MD->addOverriddenMethod(OldMD->getCanonicalDecl());
7077  if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
7078  !CheckOverridingFunctionAttributes(MD, OldMD) &&
7079  !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
7080  !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
7081  hasDeletedOverridenMethods |= OldMD->isDeleted();
7082  hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
7083  AddedAny = true;
7084  }
7085  }
7086  }
7087  }
7088 
7089  if (hasDeletedOverridenMethods && !MD->isDeleted()) {
7090  ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
7091  }
7092  if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
7093  ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
7094  }
7095 
7096  return AddedAny;
7097 }
7098 
7099 namespace {
7100  // Struct for holding all of the extra arguments needed by
7101  // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
7102  struct ActOnFDArgs {
7103  Scope *S;
7104  Declarator &D;
7105  MultiTemplateParamsArg TemplateParamLists;
7106  bool AddToScope;
7107  };
7108 } // end anonymous namespace
7109 
7110 namespace {
7111 
7112 // Callback to only accept typo corrections that have a non-zero edit distance.
7113 // Also only accept corrections that have the same parent decl.
7114 class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
7115  public:
7116  DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
7117  CXXRecordDecl *Parent)
7118  : Context(Context), OriginalFD(TypoFD),
7119  ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
7120 
7121  bool ValidateCandidate(const TypoCorrection &candidate) override {
7122  if (candidate.getEditDistance() == 0)
7123  return false;
7124 
7125  SmallVector<unsigned, 1> MismatchedParams;
7126  for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
7127  CDeclEnd = candidate.end();
7128  CDecl != CDeclEnd; ++CDecl) {
7129  FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
7130 
7131  if (FD && !FD->hasBody() &&
7132  hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
7133  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
7134  CXXRecordDecl *Parent = MD->getParent();
7135  if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
7136  return true;
7137  } else if (!ExpectedParent) {
7138  return true;
7139  }
7140  }
7141  }
7142 
7143  return false;
7144  }
7145 
7146  private:
7148  FunctionDecl *OriginalFD;
7149  CXXRecordDecl *ExpectedParent;
7150 };
7151 
7152 } // end anonymous namespace
7153 
7154 /// \brief Generate diagnostics for an invalid function redeclaration.
7155 ///
7156 /// This routine handles generating the diagnostic messages for an invalid
7157 /// function redeclaration, including finding possible similar declarations
7158 /// or performing typo correction if there are no previous declarations with
7159 /// the same name.
7160 ///
7161 /// Returns a NamedDecl iff typo correction was performed and substituting in
7162 /// the new declaration name does not cause new errors.
7164  Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
7165  ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
7166  DeclarationName Name = NewFD->getDeclName();
7167  DeclContext *NewDC = NewFD->getDeclContext();
7168  SmallVector<unsigned, 1> MismatchedParams;
7170  TypoCorrection Correction;
7171  bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
7172  unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
7173  : diag::err_member_decl_does_not_match;
7174  LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
7175  IsLocalFriend ? Sema::LookupLocalFriendName
7178 
7179  NewFD->setInvalidDecl();
7180  if (IsLocalFriend)
7181  SemaRef.LookupName(Prev, S);
7182  else
7183  SemaRef.LookupQualifiedName(Prev, NewDC);
7184  assert(!Prev.isAmbiguous() &&
7185  "Cannot have an ambiguity in previous-declaration lookup");
7186  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
7187  if (!Prev.empty()) {
7188  for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
7189  Func != FuncEnd; ++Func) {
7190  FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
7191  if (FD &&
7192  hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
7193  // Add 1 to the index so that 0 can mean the mismatch didn't
7194  // involve a parameter
7195  unsigned ParamNum =
7196  MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
7197  NearMatches.push_back(std::make_pair(FD, ParamNum));
7198  }
7199  }
7200  // If the qualified name lookup yielded nothing, try typo correction
7201  } else if ((Correction = SemaRef.CorrectTypo(
7202  Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
7203  &ExtraArgs.D.getCXXScopeSpec(),
7204  llvm::make_unique<DifferentNameValidatorCCC>(
7205  SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr),
7206  Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
7207  // Set up everything for the call to ActOnFunctionDeclarator
7208  ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
7209  ExtraArgs.D.getIdentifierLoc());
7210  Previous.clear();
7211  Previous.setLookupName(Correction.getCorrection());
7212  for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
7213  CDeclEnd = Correction.end();
7214  CDecl != CDeclEnd; ++CDecl) {
7215  FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
7216  if (FD && !FD->hasBody() &&
7217  hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
7218  Previous.addDecl(FD);
7219  }
7220  }
7221  bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
7222 
7223  NamedDecl *Result;
7224  // Retry building the function declaration with the new previous
7225  // declarations, and with errors suppressed.
7226  {
7227  // Trap errors.
7228  Sema::SFINAETrap Trap(SemaRef);
7229 
7230  // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
7231  // pieces need to verify the typo-corrected C++ declaration and hopefully
7232  // eliminate the need for the parameter pack ExtraArgs.
7233  Result = SemaRef.ActOnFunctionDeclarator(
7234  ExtraArgs.S, ExtraArgs.D,
7235  Correction.getCorrectionDecl()->getDeclContext(),
7236  NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
7237  ExtraArgs.AddToScope);
7238 
7239  if (Trap.hasErrorOccurred())
7240  Result = nullptr;
7241  }
7242 
7243  if (Result) {
7244  // Determine which correction we picked.
7245  Decl *Canonical = Result->getCanonicalDecl();
7246  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7247  I != E; ++I)
7248  if ((*I)->getCanonicalDecl() == Canonical)
7249  Correction.setCorrectionDecl(*I);
7250 
7251  SemaRef.diagnoseTypo(
7252  Correction,
7253  SemaRef.PDiag(IsLocalFriend
7254  ? diag::err_no_matching_local_friend_suggest
7255  : diag::err_member_decl_does_not_match_suggest)
7256  << Name << NewDC << IsDefinition);
7257  return Result;
7258  }
7259 
7260  // Pretend the typo correction never occurred
7261  ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
7262  ExtraArgs.D.getIdentifierLoc());
7263  ExtraArgs.D.setRedeclaration(wasRedeclaration);
7264  Previous.clear();
7265  Previous.setLookupName(Name);
7266  }
7267 
7268  SemaRef.Diag(NewFD->getLocation(), DiagMsg)
7269  << Name << NewDC << IsDefinition << NewFD->getLocation();
7270 
7271  bool NewFDisConst = false;
7272  if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
7273  NewFDisConst = NewMD->isConst();
7274 
7275  for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
7276  NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
7277  NearMatch != NearMatchEnd; ++NearMatch) {
7278  FunctionDecl *FD = NearMatch->first;
7279  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
7280  bool FDisConst = MD && MD->isConst();
7281  bool IsMember = MD || !IsLocalFriend;
7282 
7283  // FIXME: These notes are poorly worded for the local friend case.
7284  if (unsigned Idx = NearMatch->second) {
7285  ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
7286  SourceLocation Loc = FDParam->getTypeSpecStartLoc();
7287  if (Loc.isInvalid()) Loc = FD->getLocation();
7288  SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
7289  : diag::note_local_decl_close_param_match)
7290  << Idx << FDParam->getType()
7291  << NewFD->getParamDecl(Idx - 1)->getType();
7292  } else if (FDisConst != NewFDisConst) {
7293  SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
7294  << NewFDisConst << FD->getSourceRange().getEnd();
7295  } else
7296  SemaRef.Diag(FD->getLocation(),
7297  IsMember ? diag::note_member_def_close_match
7298  : diag::note_local_decl_close_match);
7299  }
7300  return nullptr;
7301 }
7302 
7304  switch (D.getDeclSpec().getStorageClassSpec()) {
7305  default: llvm_unreachable("Unknown storage class!");
7306  case DeclSpec::SCS_auto:
7308  case DeclSpec::SCS_mutable:
7309  SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7310  diag::err_typecheck_sclass_func);
7311  D.setInvalidType();
7312  break;
7313  case DeclSpec::SCS_unspecified: break;
7314  case DeclSpec::SCS_extern:
7316  return SC_None;
7317  return SC_Extern;
7318  case DeclSpec::SCS_static: {
7319  if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
7320  // C99 6.7.1p5:
7321  // The declaration of an identifier for a function that has
7322  // block scope shall have no explicit storage-class specifier
7323  // other than extern
7324  // See also (C++ [dcl.stc]p4).
7325  SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7326  diag::err_static_block_func);
7327  break;
7328  } else
7329  return SC_Static;
7330  }
7332  }
7333 
7334  // No explicit storage class has already been returned
7335  return SC_None;
7336 }
7337 
7339  DeclContext *DC, QualType &R,
7340  TypeSourceInfo *TInfo,
7341  StorageClass SC,
7342  bool &IsVirtualOkay) {
7343  DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
7344  DeclarationName Name = NameInfo.getName();
7345 
7346  FunctionDecl *NewFD = nullptr;
7347  bool isInline = D.getDeclSpec().isInlineSpecified();
7348 
7349  if (!SemaRef.getLangOpts().CPlusPlus) {
7350  // Determine whether the function was written with a
7351  // prototype. This true when:
7352  // - there is a prototype in the declarator, or
7353  // - the type R of the function is some kind of typedef or other reference
7354  // to a type name (which eventually refers to a function type).
7355  bool HasPrototype =
7357  (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
7358 
7359  NewFD = FunctionDecl::Create(SemaRef.Context, DC,
7360  D.getLocStart(), NameInfo, R,
7361  TInfo, SC, isInline,
7362  HasPrototype, false);
7363  if (D.isInvalidType())
7364  NewFD->setInvalidDecl();
7365 
7366  return NewFD;
7367  }
7368 
7369  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
7370  bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
7371 
7372  // Check that the return type is not an abstract class type.
7373  // For record types, this is done by the AbstractClassUsageDiagnoser once
7374  // the class has been completely parsed.
7375  if (!DC->isRecord() &&
7376  SemaRef.RequireNonAbstractType(
7377  D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
7378  diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
7379  D.setInvalidType();
7380 
7382  // This is a C++ constructor declaration.
7383  assert(DC->isRecord() &&
7384  "Constructors can only be declared in a member context");
7385 
7386  R = SemaRef.CheckConstructorDeclarator(D, R, SC);
7387  return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
7388  D.getLocStart(), NameInfo,
7389  R, TInfo, isExplicit, isInline,
7390  /*isImplicitlyDeclared=*/false,
7391  isConstexpr);
7392 
7393  } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7394  // This is a C++ destructor declaration.
7395  if (DC->isRecord()) {
7396  R = SemaRef.CheckDestructorDeclarator(D, R, SC);
7397  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
7399  SemaRef.Context, Record,
7400  D.getLocStart(),
7401  NameInfo, R, TInfo, isInline,
7402  /*isImplicitlyDeclared=*/false);
7403 
7404  // If the class is complete, then we now create the implicit exception
7405  // specification. If the class is incomplete or dependent, we can't do
7406  // it yet.
7407  if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
7408  Record->getDefinition() && !Record->isBeingDefined() &&
7409  R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
7410  SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
7411  }
7412 
7413  IsVirtualOkay = true;
7414  return NewDD;
7415 
7416  } else {
7417  SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
7418  D.setInvalidType();
7419 
7420  // Create a FunctionDecl to satisfy the function definition parsing
7421  // code path.
7422  return FunctionDecl::Create(SemaRef.Context, DC,
7423  D.getLocStart(),
7424  D.getIdentifierLoc(), Name, R, TInfo,
7425  SC, isInline,
7426  /*hasPrototype=*/true, isConstexpr);
7427  }
7428 
7430  if (!DC->isRecord()) {
7431  SemaRef.Diag(D.getIdentifierLoc(),
7432  diag::err_conv_function_not_member);
7433  return nullptr;
7434  }
7435 
7436  SemaRef.CheckConversionDeclarator(D, R, SC);
7437  IsVirtualOkay = true;
7438  return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
7439  D.getLocStart(), NameInfo,
7440  R, TInfo, isInline, isExplicit,
7441  isConstexpr, SourceLocation());
7442 
7443  } else if (DC->isRecord()) {
7444  // If the name of the function is the same as the name of the record,
7445  // then this must be an invalid constructor that has a return type.
7446  // (The parser checks for a return type and makes the declarator a
7447  // constructor if it has no return type).
7448  if (Name.getAsIdentifierInfo() &&
7449  Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
7450  SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
7452  << SourceRange(D.getIdentifierLoc());
7453  return nullptr;
7454  }
7455 
7456  // This is a C++ method declaration.
7458  cast<CXXRecordDecl>(DC),
7459  D.getLocStart(), NameInfo, R,
7460  TInfo, SC, isInline,
7461  isConstexpr, SourceLocation());
7462  IsVirtualOkay = !Ret->isStatic();
7463  return Ret;
7464  } else {
7465  bool isFriend =
7466  SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
7467  if (!isFriend && SemaRef.CurContext->isRecord())
7468  return nullptr;
7469 
7470  // Determine whether the function was written with a
7471  // prototype. This true when:
7472  // - we're in C++ (where every function has a prototype),
7473  return FunctionDecl::Create(SemaRef.Context, DC,
7474  D.getLocStart(),
7475  NameInfo, R, TInfo, SC, isInline,
7476  true/*HasPrototype*/, isConstexpr);
7477  }
7478 }
7479 
7487 };
7488 
7490  if (PT->isPointerType()) {
7491  QualType PointeeType = PT->getPointeeType();
7492  if (PointeeType->isPointerType())
7493  return PtrPtrKernelParam;
7494  return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
7495  : PtrKernelParam;
7496  }
7497 
7498  // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
7499  // be used as builtin types.
7500 
7501  if (PT->isImageType())
7502  return PtrKernelParam;
7503 
7504  if (PT->isBooleanType())
7505  return InvalidKernelParam;
7506 
7507  if (PT->isEventT())
7508  return InvalidKernelParam;
7509 
7510  if (PT->isHalfType())
7511  return InvalidKernelParam;
7512 
7513  if (PT->isRecordType())
7514  return RecordKernelParam;
7515 
7516  return ValidKernelParam;
7517 }
7518 
7520  Sema &S,
7521  Declarator &D,
7522  ParmVarDecl *Param,
7523  llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
7524  QualType PT = Param->getType();
7525 
7526  // Cache the valid types we encounter to avoid rechecking structs that are
7527  // used again
7528  if (ValidTypes.count(PT.getTypePtr()))
7529  return;
7530 
7531  switch (getOpenCLKernelParameterType(PT)) {
7532  case PtrPtrKernelParam:
7533  // OpenCL v1.2 s6.9.a:
7534  // A kernel function argument cannot be declared as a
7535  // pointer to a pointer type.
7536  S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
7537  D.setInvalidType();
7538  return;
7539 
7540  case PrivatePtrKernelParam:
7541  // OpenCL v1.2 s6.9.a:
7542  // A kernel function argument cannot be declared as a
7543  // pointer to the private address space.
7544  S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
7545  D.setInvalidType();
7546  return;
7547 
7548  // OpenCL v1.2 s6.9.k:
7549  // Arguments to kernel functions in a program cannot be declared with the
7550  // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
7551  // uintptr_t or a struct and/or union that contain fields declared to be
7552  // one of these built-in scalar types.
7553 
7554  case InvalidKernelParam:
7555  // OpenCL v1.2 s6.8 n:
7556  // A kernel function argument cannot be declared
7557  // of event_t type.
7558  S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7559  D.setInvalidType();
7560  return;
7561 
7562  case PtrKernelParam:
7563  case ValidKernelParam:
7564  ValidTypes.insert(PT.getTypePtr());
7565  return;
7566 
7567  case RecordKernelParam:
7568  break;
7569  }
7570 
7571  // Track nested structs we will inspect
7572  SmallVector<const Decl *, 4> VisitStack;
7573 
7574  // Track where we are in the nested structs. Items will migrate from
7575  // VisitStack to HistoryStack as we do the DFS for bad field.
7576  SmallVector<const FieldDecl *, 4> HistoryStack;
7577  HistoryStack.push_back(nullptr);
7578 
7579  const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
7580  VisitStack.push_back(PD);
7581 
7582  assert(VisitStack.back() && "First decl null?");
7583 
7584  do {
7585  const Decl *Next = VisitStack.pop_back_val();
7586  if (!Next) {
7587  assert(!HistoryStack.empty());
7588  // Found a marker, we have gone up a level
7589  if (const FieldDecl *Hist = HistoryStack.pop_back_val())
7590  ValidTypes.insert(Hist->getType().getTypePtr());
7591 
7592  continue;
7593  }
7594 
7595  // Adds everything except the original parameter declaration (which is not a
7596  // field itself) to the history stack.
7597  const RecordDecl *RD;
7598  if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
7599  HistoryStack.push_back(Field);
7600  RD = Field->getType()->castAs<RecordType>()->getDecl();
7601  } else {
7602  RD = cast<RecordDecl>(Next);
7603  }
7604 
7605  // Add a null marker so we know when we've gone back up a level
7606  VisitStack.push_back(nullptr);
7607 
7608  for (const auto *FD : RD->fields()) {
7609  QualType QT = FD->getType();
7610 
7611  if (ValidTypes.count(QT.getTypePtr()))
7612  continue;
7613 
7615  if (ParamType == ValidKernelParam)
7616  continue;
7617 
7618  if (ParamType == RecordKernelParam) {
7619  VisitStack.push_back(FD);
7620  continue;
7621  }
7622 
7623  // OpenCL v1.2 s6.9.p:
7624  // Arguments to kernel functions that are declared to be a struct or union
7625  // do not allow OpenCL objects to be passed as elements of the struct or
7626  // union.
7627  if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
7628  ParamType == PrivatePtrKernelParam) {
7629  S.Diag(Param->getLocation(),
7630  diag::err_record_with_pointers_kernel_param)
7631  << PT->isUnionType()
7632  << PT;
7633  } else {
7634  S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7635  }
7636 
7637  S.Diag(PD->getLocation(), diag::note_within_field_of_type)
7638  << PD->getDeclName();
7639 
7640  // We have an error, now let's go back up through history and show where
7641  // the offending field came from
7643  I = HistoryStack.begin() + 1,
7644  E = HistoryStack.end();
7645  I != E; ++I) {
7646  const FieldDecl *OuterField = *I;
7647  S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
7648  << OuterField->getType();
7649  }
7650 
7651  S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
7652  << QT->isPointerType()
7653  << QT;
7654  D.setInvalidType();
7655  return;
7656  }
7657  } while (!VisitStack.empty());
7658 }
7659 
7660 NamedDecl*
7663  MultiTemplateParamsArg TemplateParamLists,
7664  bool &AddToScope) {
7665  QualType R = TInfo->getType();
7666 
7667  assert(R.getTypePtr()->isFunctionType());
7668 
7669  // TODO: consider using NameInfo for diagnostic.
7670  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
7671  DeclarationName Name = NameInfo.getName();
7672  StorageClass SC = getFunctionStorageClass(*this, D);
7673 
7676  diag::err_invalid_thread)
7677  << DeclSpec::getSpecifierName(TSCS);
7678 
7680  adjustMemberFunctionCC(R, D.isStaticMember(), D.isCtorOrDtor(),
7681  D.getIdentifierLoc());
7682 
7683  bool isFriend = false;
7684  FunctionTemplateDecl *FunctionTemplate = nullptr;
7685  bool isExplicitSpecialization = false;
7686  bool isFunctionTemplateSpecialization = false;
7687 
7688  bool isDependentClassScopeExplicitSpecialization = false;
7689  bool HasExplicitTemplateArgs = false;
7690  TemplateArgumentListInfo TemplateArgs;
7691 
7692  bool isVirtualOkay = false;
7693 
7694  DeclContext *OriginalDC = DC;
7695  bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
7696 
7697  FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
7698  isVirtualOkay);
7699  if (!NewFD) return nullptr;
7700 
7701  if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
7702  NewFD->setTopLevelDeclInObjCContainer();
7703 
7704  // Set the lexical context. If this is a function-scope declaration, or has a
7705  // C++ scope specifier, or is the object of a friend declaration, the lexical
7706  // context will be different from the semantic context.
7707  NewFD->setLexicalDeclContext(CurContext);
7708 
7709  if (IsLocalExternDecl)
7710  NewFD->setLocalExternDecl();
7711 
7712  if (getLangOpts().CPlusPlus) {
7713  bool isInline = D.getDeclSpec().isInlineSpecified();
7714  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
7715  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
7716  bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
7717  bool isConcept = D.getDeclSpec().isConceptSpecified();
7718  isFriend = D.getDeclSpec().isFriendSpecified();
7719  if (isFriend && !isInline && D.isFunctionDefinition()) {
7720  // C++ [class.friend]p5
7721  // A function can be defined in a friend declaration of a
7722  // class . . . . Such a function is implicitly inline.
7723  NewFD->setImplicitlyInline();
7724  }
7725 
7726  // If this is a method defined in an __interface, and is not a constructor
7727  // or an overloaded operator, then set the pure flag (isVirtual will already
7728  // return true).
7729  if (const CXXRecordDecl *Parent =
7730  dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
7731  if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
7732  NewFD->setPure(true);
7733 
7734  // C++ [class.union]p2
7735  // A union can have member functions, but not virtual functions.
7736  if (isVirtual && Parent->isUnion())
7737  Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
7738  }
7739 
7740  SetNestedNameSpecifier(NewFD, D);
7741  isExplicitSpecialization = false;
7742  isFunctionTemplateSpecialization = false;
7743  if (D.isInvalidType())
7744  NewFD->setInvalidDecl();
7745 
7746  // Match up the template parameter lists with the scope specifier, then
7747  // determine whether we have a template or a template specialization.
7748  bool Invalid = false;
7749  if (TemplateParameterList *TemplateParams =
7750  MatchTemplateParametersToScopeSpecifier(
7752  D.getCXXScopeSpec(),
7754  ? D.getName().TemplateId
7755  : nullptr,
7756  TemplateParamLists, isFriend, isExplicitSpecialization,
7757  Invalid)) {
7758  if (TemplateParams->size() > 0) {
7759  // This is a function template
7760 
7761  // Check that we can declare a template here.
7762  if (CheckTemplateDeclScope(S, TemplateParams))
7763  NewFD->setInvalidDecl();
7764 
7765  // A destructor cannot be a template.
7767  Diag(NewFD->getLocation(), diag::err_destructor_template);
7768  NewFD->setInvalidDecl();
7769  }
7770 
7771  // If we're adding a template to a dependent context, we may need to
7772  // rebuilding some of the types used within the template parameter list,
7773  // now that we know what the current instantiation is.
7774  if (DC->isDependentContext()) {
7775  ContextRAII SavedContext(*this, DC);
7776  if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
7777  Invalid = true;
7778  }
7779 
7780  FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
7781  NewFD->getLocation(),
7782  Name, TemplateParams,
7783  NewFD);
7784  FunctionTemplate->setLexicalDeclContext(CurContext);
7785  NewFD->setDescribedFunctionTemplate(FunctionTemplate);
7786 
7787  // For source fidelity, store the other template param lists.
7788  if (TemplateParamLists.size() > 1) {
7790  TemplateParamLists.drop_back(1));
7791  }
7792  } else {
7793  // This is a function template specialization.
7794  isFunctionTemplateSpecialization = true;
7795  // For source fidelity, store all the template param lists.
7796  if (TemplateParamLists.size() > 0)
7797  NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
7798 
7799  // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
7800  if (isFriend) {
7801  // We want to remove the "template<>", found here.
7802  SourceRange RemoveRange = TemplateParams->getSourceRange();
7803 
7804  // If we remove the template<> and the name is not a
7805  // template-id, we're actually silently creating a problem:
7806  // the friend declaration will refer to an untemplated decl,
7807  // and clearly the user wants a template specialization. So
7808  // we need to insert '<>' after the name.
7809  SourceLocation InsertLoc;
7811  InsertLoc = D.getName().getSourceRange().getEnd();
7812  InsertLoc = getLocForEndOfToken(InsertLoc);
7813  }
7814 
7815  Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
7816  << Name << RemoveRange
7817  << FixItHint::CreateRemoval(RemoveRange)
7818  << FixItHint::CreateInsertion(InsertLoc, "<>");
7819  }
7820  }
7821  }
7822  else {
7823  // All template param lists were matched against the scope specifier:
7824  // this is NOT (an explicit specialization of) a template.
7825  if (TemplateParamLists.size() > 0)
7826  // For source fidelity, store all the template param lists.
7827  NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
7828  }
7829 
7830  if (Invalid) {
7831  NewFD->setInvalidDecl();
7832  if (FunctionTemplate)
7833  FunctionTemplate->setInvalidDecl();
7834  }
7835 
7836  // C++ [dcl.fct.spec]p5:
7837  // The virtual specifier shall only be used in declarations of
7838  // nonstatic class member functions that appear within a
7839  // member-specification of a class declaration; see 10.3.
7840  //
7841  if (isVirtual && !NewFD->isInvalidDecl()) {
7842  if (!isVirtualOkay) {
7844  diag::err_virtual_non_function);
7845  } else if (!CurContext->isRecord()) {
7846  // 'virtual' was specified outside of the class.
7848  diag::err_virtual_out_of_class)
7850  } else if (NewFD->getDescribedFunctionTemplate()) {
7851  // C++ [temp.mem]p3:
7852  // A member function template shall not be virtual.
7854  diag::err_virtual_member_function_template)
7856  } else {
7857  // Okay: Add virtual to the method.
7858  NewFD->setVirtualAsWritten(true);
7859  }
7860 
7861  if (getLangOpts().CPlusPlus14 &&
7862  NewFD->getReturnType()->isUndeducedType())
7863  Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
7864  }
7865 
7866  if (getLangOpts().CPlusPlus14 &&
7867  (NewFD->isDependentContext() ||
7868  (isFriend && CurContext->isDependentContext())) &&
7869  NewFD->getReturnType()->isUndeducedType()) {
7870  // If the function template is referenced directly (for instance, as a
7871  // member of the current instantiation), pretend it has a dependent type.
7872  // This is not really justified by the standard, but is the only sane
7873  // thing to do.
7874  // FIXME: For a friend function, we have not marked the function as being
7875  // a friend yet, so 'isDependentContext' on the FD doesn't work.
7876  const FunctionProtoType *FPT =
7877  NewFD->getType()->castAs<FunctionProtoType>();
7878  QualType Result =
7879  SubstAutoType(FPT->getReturnType(), Context.DependentTy);
7880  NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
7881  FPT->getExtProtoInfo()));
7882  }
7883 
7884  // C++ [dcl.fct.spec]p3:
7885  // The inline specifier shall not appear on a block scope function
7886  // declaration.
7887  if (isInline && !NewFD->isInvalidDecl()) {
7888  if (CurContext->isFunctionOrMethod()) {
7889  // 'inline' is not allowed on block scope function declaration.
7891  diag::err_inline_declaration_block_scope) << Name
7893  }
7894  }
7895 
7896  // C++ [dcl.fct.spec]p6:
7897  // The explicit specifier shall be used only in the declaration of a
7898  // constructor or conversion function within its class definition;
7899  // see 12.3.1 and 12.3.2.
7900  if (isExplicit && !NewFD->isInvalidDecl()) {
7901  if (!CurContext->isRecord()) {
7902  // 'explicit' was specified outside of the class.
7904  diag::err_explicit_out_of_class)
7906  } else if (!isa<CXXConstructorDecl>(NewFD) &&
7907  !isa<CXXConversionDecl>(NewFD)) {
7908  // 'explicit' was specified on a function that wasn't a constructor
7909  // or conversion function.
7911  diag::err_explicit_non_ctor_or_conv_function)
7913  }
7914  }
7915 
7916  if (isConstexpr) {
7917  // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
7918  // are implicitly inline.
7919  NewFD->setImplicitlyInline();
7920 
7921  // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
7922  // be either constructors or to return a literal type. Therefore,
7923  // destructors cannot be declared constexpr.
7924  if (isa<CXXDestructorDecl>(NewFD))
7925  Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
7926  }
7927 
7928  if (isConcept) {
7929  // This is a function concept.
7931  FTD->setConcept();
7932 
7933  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
7934  // applied only to the definition of a function template [...]
7935  if (!D.isFunctionDefinition()) {
7937  diag::err_function_concept_not_defined);
7938  NewFD->setInvalidDecl();
7939  }
7940 
7941  // C++ Concepts TS [dcl.spec.concept]p1: [...] A function concept shall
7942  // have no exception-specification and is treated as if it were specified
7943  // with noexcept(true) (15.4). [...]
7944  if (const FunctionProtoType *FPT = R->getAs<FunctionProtoType>()) {
7945  if (FPT->hasExceptionSpec()) {
7946  SourceRange Range;
7947  if (D.isFunctionDeclarator())
7949  Diag(NewFD->getLocation(), diag::err_function_concept_exception_spec)
7950  << FixItHint::CreateRemoval(Range);
7951  NewFD->setInvalidDecl();
7952  } else {
7954  }
7955 
7956  // C++ Concepts TS [dcl.spec.concept]p5: A function concept has the
7957  // following restrictions:
7958  // - The declared return type shall have the type bool.
7959  if (!Context.hasSameType(FPT->getReturnType(), Context.BoolTy)) {
7960  Diag(D.getIdentifierLoc(), diag::err_function_concept_bool_ret);
7961  NewFD->setInvalidDecl();
7962  }
7963 
7964  // C++ Concepts TS [dcl.spec.concept]p5: A function concept has the
7965  // following restrictions:
7966  // - The declaration's parameter list shall be equivalent to an empty
7967  // parameter list.
7968  if (FPT->getNumParams() > 0 || FPT->isVariadic())
7969  Diag(NewFD->getLocation(), diag::err_function_concept_with_params);
7970  }
7971 
7972  // C++ Concepts TS [dcl.spec.concept]p2: Every concept definition is
7973  // implicity defined to be a constexpr declaration (implicitly inline)
7974  NewFD->setImplicitlyInline();
7975 
7976  // C++ Concepts TS [dcl.spec.concept]p2: A concept definition shall not
7977  // be declared with the thread_local, inline, friend, or constexpr
7978  // specifiers, [...]
7979  if (isInline) {
7981  diag::err_concept_decl_invalid_specifiers)
7982  << 1 << 1;
7983  NewFD->setInvalidDecl(true);
7984  }
7985 
7986  if (isFriend) {
7988  diag::err_concept_decl_invalid_specifiers)
7989  << 1 << 2;
7990  NewFD->setInvalidDecl(true);
7991  }
7992 
7993  if (isConstexpr) {
7995  diag::err_concept_decl_invalid_specifiers)
7996  << 1 << 3;
7997  NewFD->setInvalidDecl(true);
7998  }
7999 
8000  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
8001  // applied only to the definition of a function template or variable
8002  // template, declared in namespace scope.
8003  if (isFunctionTemplateSpecialization) {
8005  diag::err_concept_specified_specialization) << 1;
8006  NewFD->setInvalidDecl(true);
8007  return NewFD;
8008  }
8009  }
8010 
8011  // If __module_private__ was specified, mark the function accordingly.
8013  if (isFunctionTemplateSpecialization) {
8014  SourceLocation ModulePrivateLoc
8016  Diag(ModulePrivateLoc, diag::err_module_private_specialization)
8017  << 0
8018  << FixItHint::CreateRemoval(ModulePrivateLoc);
8019  } else {
8020  NewFD->setModulePrivate();
8021  if (FunctionTemplate)
8022  FunctionTemplate->setModulePrivate();
8023  }
8024  }
8025 
8026  if (isFriend) {
8027  if (FunctionTemplate) {
8028  FunctionTemplate->setObjectOfFriendDecl();
8029  FunctionTemplate->setAccess(AS_public);
8030  }
8031  NewFD->setObjectOfFriendDecl();
8032  NewFD->setAccess(AS_public);
8033  }
8034 
8035  // If a function is defined as defaulted or deleted, mark it as such now.
8036  // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
8037  // definition kind to FDK_Definition.
8038  switch (D.getFunctionDefinitionKind()) {
8039  case FDK_Declaration:
8040  case FDK_Definition:
8041  break;
8042 
8043  case FDK_Defaulted:
8044  NewFD->setDefaulted();
8045  break;
8046 
8047  case FDK_Deleted:
8048  NewFD->setDeletedAsWritten();
8049  break;
8050  }
8051 
8052  if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
8053  D.isFunctionDefinition()) {
8054  // C++ [class.mfct]p2:
8055  // A member function may be defined (8.4) in its class definition, in
8056  // which case it is an inline member function (7.1.2)
8057  NewFD->setImplicitlyInline();
8058  }
8059 
8060  if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
8061  !CurContext->isRecord()) {
8062  // C++ [class.static]p1:
8063  // A data or function member of a class may be declared static
8064  // in a class definition, in which case it is a static member of
8065  // the class.
8066 
8067  // Complain about the 'static' specifier if it's on an out-of-line
8068  // member function definition.
8070  diag::err_static_out_of_line)
8072  }
8073 
8074  // C++11 [except.spec]p15:
8075  // A deallocation function with no exception-specification is treated
8076  // as if it were specified with noexcept(true).
8077  const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
8078  if ((Name.getCXXOverloadedOperator() == OO_Delete ||
8079  Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
8080  getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
8082  FPT->getReturnType(), FPT->getParamTypes(),
8084  }
8085 
8086  // Filter out previous declarations that don't match the scope.
8087  FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
8088  D.getCXXScopeSpec().isNotEmpty() ||
8089  isExplicitSpecialization ||
8090  isFunctionTemplateSpecialization);
8091 
8092  // Handle GNU asm-label extension (encoded as an attribute).
8093  if (Expr *E = (Expr*) D.getAsmLabel()) {
8094  // The parser guarantees this is a string.
8095  StringLiteral *SE = cast<StringLiteral>(E);
8096  NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
8097  SE->getString(), 0));
8098  } else if (!ExtnameUndeclaredIdentifiers.empty()) {
8100  ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
8101  if (I != ExtnameUndeclaredIdentifiers.end()) {
8102  if (isDeclExternC(NewFD)) {
8103  NewFD->addAttr(I->second);
8104  ExtnameUndeclaredIdentifiers.erase(I);
8105  } else
8106  Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
8107  << /*Variable*/0 << NewFD;
8108  }
8109  }
8110 
8111  // Copy the parameter declarations from the declarator D to the function
8112  // declaration NewFD, if they are available. First scavenge them into Params.
8114  if (D.isFunctionDeclarator()) {
8116 
8117  // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
8118  // function that takes no arguments, not a function that takes a
8119  // single void argument.
8120  // We let through "const void" here because Sema::GetTypeForDeclarator
8121  // already checks for that case.
8122  if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
8123  for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
8124  ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
8125  assert(Param->getDeclContext() != NewFD && "Was set before ?");
8126  Param->setDeclContext(NewFD);
8127  Params.push_back(Param);
8128 
8129  if (Param->isInvalidDecl())
8130  NewFD->setInvalidDecl();
8131  }
8132  }
8133  } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
8134  // When we're declaring a function with a typedef, typeof, etc as in the
8135  // following example, we'll need to synthesize (unnamed)
8136  // parameters for use in the declaration.
8137  //
8138  // @code
8139  // typedef void fn(int);
8140  // fn f;
8141  // @endcode
8142 
8143  // Synthesize a parameter for each argument type.
8144  for (const auto &AI : FT->param_types()) {
8145  ParmVarDecl *Param =
8146  BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
8147  Param->setScopeInfo(0, Params.size());
8148  Params.push_back(Param);
8149  }
8150  } else {
8151  assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
8152  "Should not need args for typedef of non-prototype fn");
8153  }
8154 
8155  // Finally, we know we have the right number of parameters, install them.
8156  NewFD->setParams(Params);
8157 
8158  // Find all anonymous symbols defined during the declaration of this function
8159  // and add to NewFD. This lets us track decls such 'enum Y' in:
8160  //
8161  // void f(enum Y {AA} x) {}
8162  //
8163  // which would otherwise incorrectly end up in the translation unit scope.
8164  NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
8165  DeclsInPrototypeScope.clear();
8166 
8167  if (D.getDeclSpec().isNoreturnSpecified())
8168  NewFD->addAttr(
8169  ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
8170  Context, 0));
8171 
8172  // Functions returning a variably modified type violate C99 6.7.5.2p2
8173  // because all functions have linkage.
8174  if (!NewFD->isInvalidDecl() &&
8175  NewFD->getReturnType()->isVariablyModifiedType()) {
8176  Diag(NewFD->getLocation(), diag::err_vm_func_decl);
8177  NewFD->setInvalidDecl();
8178  }
8179 
8180  // Apply an implicit SectionAttr if #pragma code_seg is active.
8181  if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
8182  !NewFD->hasAttr<SectionAttr>()) {
8183  NewFD->addAttr(
8184  SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
8185  CodeSegStack.CurrentValue->getString(),
8186  CodeSegStack.CurrentPragmaLocation));
8187  if (UnifySection(CodeSegStack.CurrentValue->getString(),
8190  NewFD))
8191  NewFD->dropAttr<SectionAttr>();
8192  }
8193 
8194  // Handle attributes.
8195  ProcessDeclAttributes(S, NewFD, D);
8196 
8197  if (getLangOpts().CUDA)
8198  maybeAddCUDAHostDeviceAttrs(S, NewFD, Previous);
8199 
8200  if (getLangOpts().OpenCL) {
8201  // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
8202  // type declaration will generate a compilation error.
8203  unsigned AddressSpace = NewFD->getReturnType().getAddressSpace();
8204  if (AddressSpace == LangAS::opencl_local ||
8205  AddressSpace == LangAS::opencl_global ||
8206  AddressSpace == LangAS::opencl_constant) {
8207  Diag(NewFD->getLocation(),
8208  diag::err_opencl_return_value_with_address_space);
8209  NewFD->setInvalidDecl();
8210  }
8211  }
8212 
8213  if (!getLangOpts().CPlusPlus) {
8214  // Perform semantic checking on the function declaration.
8215  bool isExplicitSpecialization=false;
8216  if (!NewFD->isInvalidDecl() && NewFD->isMain())
8217  CheckMain(NewFD, D.getDeclSpec());
8218 
8219  if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
8220  CheckMSVCRTEntryPoint(NewFD);
8221 
8222  if (!NewFD->isInvalidDecl())
8223  D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
8224  isExplicitSpecialization));
8225  else if (!Previous.empty())
8226  // Recover gracefully from an invalid redeclaration.
8227  D.setRedeclaration(true);
8228  assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
8230  "previous declaration set still overloaded");
8231 
8232  // Diagnose no-prototype function declarations with calling conventions that
8233  // don't support variadic calls. Only do this in C and do it after merging
8234  // possibly prototyped redeclarations.
8235  const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
8236  if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
8237  CallingConv CC = FT->getExtInfo().getCC();
8238  if (!supportsVariadicCall(CC)) {
8239  // Windows system headers sometimes accidentally use stdcall without
8240  // (void) parameters, so we relax this to a warning.
8241  int DiagID =
8242  CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
8243  Diag(NewFD->getLocation(), DiagID)
8245  }
8246  }
8247  } else {
8248  // C++11 [replacement.functions]p3:
8249  // The program's definitions shall not be specified as inline.
8250  //
8251  // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
8252  //
8253  // Suppress the diagnostic if the function is __attribute__((used)), since
8254  // that forces an external definition to be emitted.
8255  if (D.getDeclSpec().isInlineSpecified() &&
8257  !NewFD->hasAttr<UsedAttr>())
8259  diag::ext_operator_new_delete_declared_inline)
8260  << NewFD->getDeclName();
8261 
8262  // If the declarator is a template-id, translate the parser's template
8263  // argument list into our AST format.
8265  TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
8266  TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
8267  TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
8268  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
8269  TemplateId->NumArgs);
8270  translateTemplateArguments(TemplateArgsPtr,
8271  TemplateArgs);
8272 
8273  HasExplicitTemplateArgs = true;
8274 
8275  if (NewFD->isInvalidDecl()) {
8276  HasExplicitTemplateArgs = false;
8277  } else if (FunctionTemplate) {
8278  // Function template with explicit template arguments.
8279  Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
8280  << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
8281 
8282  HasExplicitTemplateArgs = false;
8283  } else {
8284  assert((isFunctionTemplateSpecialization ||
8285  D.getDeclSpec().isFriendSpecified()) &&
8286  "should have a 'template<>' for this decl");
8287  // "friend void foo<>(int);" is an implicit specialization decl.
8288  isFunctionTemplateSpecialization = true;
8289  }
8290  } else if (isFriend && isFunctionTemplateSpecialization) {
8291  // This combination is only possible in a recovery case; the user
8292  // wrote something like:
8293  // template <> friend void foo(int);
8294  // which we're recovering from as if the user had written:
8295  // friend void foo<>(int);
8296  // Go ahead and fake up a template id.
8297  HasExplicitTemplateArgs = true;
8298  TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
8299  TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
8300  }
8301 
8302  // If it's a friend (and only if it's a friend), it's possible
8303  // that either the specialized function type or the specialized
8304  // template is dependent, and therefore matching will fail. In
8305  // this case, don't check the specialization yet.
8306  bool InstantiationDependent = false;
8307  if (isFunctionTemplateSpecialization && isFriend &&
8308  (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
8310  TemplateArgs,
8311  InstantiationDependent))) {
8312  assert(HasExplicitTemplateArgs &&
8313  "friend function specialization without template args");
8314  if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
8315  Previous))
8316  NewFD->setInvalidDecl();
8317  } else if (isFunctionTemplateSpecialization) {
8318  if (CurContext->isDependentContext() && CurContext->isRecord()
8319  && !isFriend) {
8320  isDependentClassScopeExplicitSpecialization = true;
8321  Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
8322  diag::ext_function_specialization_in_class :
8323  diag::err_function_specialization_in_class)
8324  << NewFD->getDeclName();
8325  } else if (CheckFunctionTemplateSpecialization(NewFD,
8326  (HasExplicitTemplateArgs ? &TemplateArgs
8327  : nullptr),
8328  Previous))
8329  NewFD->setInvalidDecl();
8330 
8331  // C++ [dcl.stc]p1:
8332  // A storage-class-specifier shall not be specified in an explicit
8333  // specialization (14.7.3)
8336  if (Info && SC != SC_None) {
8337  if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
8338  Diag(NewFD->getLocation(),
8339  diag::err_explicit_specialization_inconsistent_storage_class)
8340  << SC
8343 
8344  else
8345  Diag(NewFD->getLocation(),
8346  diag::ext_explicit_specialization_storage_class)
8349  }
8350  } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
8351  if (CheckMemberSpecialization(NewFD, Previous))
8352  NewFD->setInvalidDecl();
8353  }
8354 
8355  // Perform semantic checking on the function declaration.
8356  if (!isDependentClassScopeExplicitSpecialization) {
8357  if (!NewFD->isInvalidDecl() && NewFD->isMain())
8358  CheckMain(NewFD, D.getDeclSpec());
8359 
8360  if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
8361  CheckMSVCRTEntryPoint(NewFD);
8362 
8363  if (!NewFD->isInvalidDecl())
8364  D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
8365  isExplicitSpecialization));
8366  else if (!Previous.empty())
8367  // Recover gracefully from an invalid redeclaration.
8368  D.setRedeclaration(true);
8369  }
8370 
8371  assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
8373  "previous declaration set still overloaded");
8374 
8375  NamedDecl *PrincipalDecl = (FunctionTemplate
8376  ? cast<NamedDecl>(FunctionTemplate)
8377  : NewFD);
8378 
8379  if (isFriend && D.isRedeclaration()) {
8380  AccessSpecifier Access = AS_public;
8381  if (!NewFD->isInvalidDecl())
8382  Access = NewFD->getPreviousDecl()->getAccess();
8383 
8384  NewFD->setAccess(Access);
8385  if (FunctionTemplate) FunctionTemplate->setAccess(Access);
8386  }
8387 
8388  if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
8389  PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
8390  PrincipalDecl->setNonMemberOperator();
8391 
8392  // If we have a function template, check the template parameter
8393  // list. This will check and merge default template arguments.
8394  if (FunctionTemplate) {
8395  FunctionTemplateDecl *PrevTemplate =
8396  FunctionTemplate->getPreviousDecl();
8397  CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
8398  PrevTemplate ? PrevTemplate->getTemplateParameters()
8399  : nullptr,
8401  ? (D.isFunctionDefinition()
8402  ? TPC_FriendFunctionTemplateDefinition
8403  : TPC_FriendFunctionTemplate)
8404  : (D.getCXXScopeSpec().isSet() &&
8405  DC && DC->isRecord() &&
8406  DC->isDependentContext())
8407  ? TPC_ClassTemplateMember
8408  : TPC_FunctionTemplate);
8409  }
8410 
8411  if (NewFD->isInvalidDecl()) {
8412  // Ignore all the rest of this.
8413  } else if (!D.isRedeclaration()) {
8414  struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
8415  AddToScope };
8416  // Fake up an access specifier if it's supposed to be a class member.
8417  if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
8418  NewFD->setAccess(AS_public);
8419 
8420  // Qualified decls generally require a previous declaration.
8421  if (D.getCXXScopeSpec().isSet()) {
8422  // ...with the major exception of templated-scope or
8423  // dependent-scope friend declarations.
8424 
8425  // TODO: we currently also suppress this check in dependent
8426  // contexts because (1) the parameter depth will be off when
8427  // matching friend templates and (2) we might actually be
8428  // selecting a friend based on a dependent factor. But there
8429  // are situations where these conditions don't apply and we
8430  // can actually do this check immediately.
8431  if (isFriend &&
8432  (TemplateParamLists.size() ||
8434  CurContext->isDependentContext())) {
8435  // ignore these
8436  } else {
8437  // The user tried to provide an out-of-line definition for a
8438  // function that is a member of a class or namespace, but there
8439  // was no such member function declared (C++ [class.mfct]p2,
8440  // C++ [namespace.memdef]p2). For example:
8441  //
8442  // class X {
8443  // void f() const;
8444  // };
8445  //
8446  // void X::f() { } // ill-formed
8447  //
8448  // Complain about this problem, and attempt to suggest close
8449  // matches (e.g., those that differ only in cv-qualifiers and
8450  // whether the parameter types are references).
8451 
8453  *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
8454  AddToScope = ExtraArgs.AddToScope;
8455  return Result;
8456  }
8457  }
8458 
8459  // Unqualified local friend declarations are required to resolve
8460  // to something.
8461  } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
8463  *this, Previous, NewFD, ExtraArgs, true, S)) {
8464  AddToScope = ExtraArgs.AddToScope;
8465  return Result;
8466  }
8467  }
8468  } else if (!D.isFunctionDefinition() &&
8469  isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
8470  !isFriend && !isFunctionTemplateSpecialization &&
8471  !isExplicitSpecialization) {
8472  // An out-of-line member function declaration must also be a
8473  // definition (C++ [class.mfct]p2).
8474  // Note that this is not the case for explicit specializations of
8475  // function templates or member functions of class templates, per
8476  // C++ [temp.expl.spec]p2. We also allow these declarations as an
8477  // extension for compatibility with old SWIG code which likes to
8478  // generate them.
8479  Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
8480  << D.getCXXScopeSpec().getRange();
8481  }
8482  }
8483 
8484  ProcessPragmaWeak(S, NewFD);
8485  checkAttributesAfterMerging(*this, *NewFD);
8486 
8487  AddKnownFunctionAttributes(NewFD);
8488 
8489  if (NewFD->hasAttr<OverloadableAttr>() &&
8490  !NewFD->getType()->getAs<FunctionProtoType>()) {
8491  Diag(NewFD->getLocation(),
8492  diag::err_attribute_overloadable_no_prototype)
8493  << NewFD;
8494 
8495  // Turn this into a variadic function with no parameters.
8496  const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
8498  Context.getDefaultCallingConvention(true, false));
8499  EPI.Variadic = true;
8500  EPI.ExtInfo = FT->getExtInfo();
8501 
8502  QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
8503  NewFD->setType(R);
8504  }
8505 
8506  // If there's a #pragma GCC visibility in scope, and this isn't a class
8507  // member, set the visibility of this function.
8508  if (!DC->isRecord() && NewFD->isExternallyVisible())
8509  AddPushedVisibilityAttribute(NewFD);
8510 
8511  // If there's a #pragma clang arc_cf_code_audited in scope, consider
8512  // marking the function.
8513  AddCFAuditedAttribute(NewFD);
8514 
8515  // If this is a function definition, check if we have to apply optnone due to
8516  // a pragma.
8517  if(D.isFunctionDefinition())
8518  AddRangeBasedOptnone(NewFD);
8519 
8520  // If this is the first declaration of an extern C variable, update
8521  // the map of such variables.
8522  if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
8523  isIncompleteDeclExternC(*this, NewFD))
8524  RegisterLocallyScopedExternCDecl(NewFD, S);
8525 
8526  // Set this FunctionDecl's range up to the right paren.
8527  NewFD->setRangeEnd(D.getSourceRange().getEnd());
8528 
8529  if (D.isRedeclaration() && !Previous.empty()) {
8531  *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD,
8532  isExplicitSpecialization || isFunctionTemplateSpecialization,
8533  D.isFunctionDefinition());
8534  }
8535 
8536  if (getLangOpts().CUDA) {
8537  IdentifierInfo *II = NewFD->getIdentifier();
8538  if (II && II->isStr("cudaConfigureCall") && !NewFD->isInvalidDecl() &&
8539  NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
8540  if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
8541  Diag(NewFD->getLocation(), diag::err_config_scalar_return);
8542 
8544  }
8545 
8546  // Variadic functions, other than a *declaration* of printf, are not allowed
8547  // in device-side CUDA code, unless someone passed
8548  // -fcuda-allow-variadic-functions.
8549  if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() &&
8550  (NewFD->hasAttr<CUDADeviceAttr>() ||
8551  NewFD->hasAttr<CUDAGlobalAttr>()) &&
8552  !(II && II->isStr("printf") && NewFD->isExternC() &&
8553  !D.isFunctionDefinition())) {
8554  Diag(NewFD->getLocation(), diag::err_variadic_device_fn);
8555  }
8556  }
8557 
8558  if (getLangOpts().CPlusPlus) {
8559  if (FunctionTemplate) {
8560  if (NewFD->isInvalidDecl())
8561  FunctionTemplate->setInvalidDecl();
8562  return FunctionTemplate;
8563  }
8564  }
8565 
8566  if (NewFD->hasAttr<OpenCLKernelAttr>()) {
8567  // OpenCL v1.2 s6.8 static is invalid for kernel functions.
8568  if ((getLangOpts().OpenCLVersion >= 120)
8569  && (SC == SC_Static)) {
8570  Diag(D.getIdentifierLoc(), diag::err_static_kernel);
8571  D.setInvalidType();
8572  }
8573 
8574  // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
8575  if (!NewFD->getReturnType()->isVoidType()) {
8576  SourceRange RTRange = NewFD->getReturnTypeSourceRange();
8577  Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
8578  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
8579  : FixItHint());
8580  D.setInvalidType();
8581  }
8582 
8583  llvm::SmallPtrSet<const Type *, 16> ValidTypes;
8584  for (auto Param : NewFD->parameters())
8585  checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
8586  }
8587  for (const ParmVarDecl *Param : NewFD->parameters()) {
8588  QualType PT = Param->getType();
8589 
8590  // OpenCL 2.0 pipe restrictions forbids pipe packet types to be non-value
8591  // types.
8592  if (getLangOpts().OpenCLVersion >= 200) {
8593  if(const PipeType *PipeTy = PT->getAs<PipeType>()) {
8594  QualType ElemTy = PipeTy->getElementType();
8595  if (ElemTy->isReferenceType() || ElemTy->isPointerType()) {
8596  Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
8597  D.setInvalidType();
8598  }
8599  }
8600  }
8601  }
8602 
8603  MarkUnusedFileScopedDecl(NewFD);
8604 
8605  // Here we have an function template explicit specialization at class scope.
8606  // The actually specialization will be postponed to template instatiation
8607  // time via the ClassScopeFunctionSpecializationDecl node.
8608  if (isDependentClassScopeExplicitSpecialization) {
8611  Context, CurContext, SourceLocation(),
8612  cast<CXXMethodDecl>(NewFD),
8613  HasExplicitTemplateArgs, TemplateArgs);
8614  CurContext->addDecl(NewSpec);
8615  AddToScope = false;
8616  }
8617 
8618  return NewFD;
8619 }
8620 
8621 /// \brief Perform semantic checking of a new function declaration.
8622 ///
8623 /// Performs semantic analysis of the new function declaration
8624 /// NewFD. This routine performs all semantic checking that does not
8625 /// require the actual declarator involved in the declaration, and is
8626 /// used both for the declaration of functions as they are parsed
8627 /// (called via ActOnDeclarator) and for the declaration of functions
8628 /// that have been instantiated via C++ template instantiation (called
8629 /// via InstantiateDecl).
8630 ///
8631 /// \param IsExplicitSpecialization whether this new function declaration is
8632 /// an explicit specialization of the previous declaration.
8633 ///
8634 /// This sets NewFD->isInvalidDecl() to true if there was an error.
8635 ///
8636 /// \returns true if the function declaration is a redeclaration.
8639  bool IsExplicitSpecialization) {
8640  assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
8641  "Variably modified return types are not handled here");
8642 
8643  // Determine whether the type of this function should be merged with
8644  // a previous visible declaration. This never happens for functions in C++,
8645  // and always happens in C if the previous declaration was visible.
8646  bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
8647  !Previous.isShadowed();
8648 
8649  bool Redeclaration = false;
8650  NamedDecl *OldDecl = nullptr;
8651 
8652  // Merge or overload the declaration with an existing declaration of
8653  // the same name, if appropriate.
8654  if (!Previous.empty()) {
8655  // Determine whether NewFD is an overload of PrevDecl or
8656  // a declaration that requires merging. If it's an overload,
8657  // there's no more work to do here; we'll just add the new
8658  // function to the scope.
8659  if (!AllowOverloadingOfFunction(Previous, Context)) {
8660  NamedDecl *Candidate = Previous.getRepresentativeDecl();
8661  if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
8662  Redeclaration = true;
8663  OldDecl = Candidate;
8664  }
8665  } else {
8666  switch (CheckOverload(S, NewFD, Previous, OldDecl,
8667  /*NewIsUsingDecl*/ false)) {
8668  case Ovl_Match:
8669  Redeclaration = true;
8670  break;
8671 
8672  case Ovl_NonFunction:
8673  Redeclaration = true;
8674  break;
8675 
8676  case Ovl_Overload:
8677  Redeclaration = false;
8678  break;
8679  }
8680 
8681  if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
8682  // If a function name is overloadable in C, then every function
8683  // with that name must be marked "overloadable".
8684  Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8685  << Redeclaration << NewFD;
8686  NamedDecl *OverloadedDecl = nullptr;
8687  if (Redeclaration)
8688  OverloadedDecl = OldDecl;
8689  else if (!Previous.empty())
8690  OverloadedDecl = Previous.getRepresentativeDecl();
8691  if (OverloadedDecl)
8692  Diag(OverloadedDecl->getLocation(),
8693  diag::note_attribute_overloadable_prev_overload);
8694  NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
8695  }
8696  }
8697  }
8698 
8699  // Check for a previous extern "C" declaration with this name.
8700  if (!Redeclaration &&
8701  checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
8702  if (!Previous.empty()) {
8703  // This is an extern "C" declaration with the same name as a previous
8704  // declaration, and thus redeclares that entity...
8705  Redeclaration = true;
8706  OldDecl = Previous.getFoundDecl();
8707  MergeTypeWithPrevious = false;
8708 
8709  // ... except in the presence of __attribute__((overloadable)).
8710  if (OldDecl->hasAttr<OverloadableAttr>()) {
8711  if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
8712  Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8713  << Redeclaration << NewFD;
8714  Diag(Previous.getFoundDecl()->getLocation(),
8715  diag::note_attribute_overloadable_prev_overload);
8716  NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
8717  }
8718  if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
8719  Redeclaration = false;
8720  OldDecl = nullptr;
8721  }
8722  }
8723  }
8724  }
8725 
8726  // C++11 [dcl.constexpr]p8:
8727  // A constexpr specifier for a non-static member function that is not
8728  // a constructor declares that member function to be const.
8729  //
8730  // This needs to be delayed until we know whether this is an out-of-line
8731  // definition of a static member function.
8732  //
8733  // This rule is not present in C++1y, so we produce a backwards
8734  // compatibility warning whenever it happens in C++11.
8735  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
8736  if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
8737  !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
8738  (MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
8739  CXXMethodDecl *OldMD = nullptr;
8740  if (OldDecl)
8741  OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction());
8742  if (!OldMD || !OldMD->isStatic()) {
8743  const FunctionProtoType *FPT =
8744  MD->getType()->castAs<FunctionProtoType>();
8748  FPT->getParamTypes(), EPI));
8749 
8750  // Warn that we did this, if we're not performing template instantiation.
8751  // In that case, we'll have warned already when the template was defined.
8752  if (ActiveTemplateInstantiations.empty()) {
8753  SourceLocation AddConstLoc;
8754  if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
8756  AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
8757 
8758  Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
8759  << FixItHint::CreateInsertion(AddConstLoc, " const");
8760  }
8761  }
8762  }
8763 
8764  if (Redeclaration) {
8765  // NewFD and OldDecl represent declarations that need to be
8766  // merged.
8767  if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
8768  NewFD->setInvalidDecl();
8769  return Redeclaration;
8770  }
8771 
8772  Previous.clear();
8773  Previous.addDecl(OldDecl);
8774 
8775  if (FunctionTemplateDecl *OldTemplateDecl
8776  = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
8777  NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
8778  FunctionTemplateDecl *NewTemplateDecl
8779  = NewFD->getDescribedFunctionTemplate();
8780  assert(NewTemplateDecl && "Template/non-template mismatch");
8781  if (CXXMethodDecl *Method
8782  = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
8783  Method->setAccess(OldTemplateDecl->getAccess());
8784  NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
8785  }
8786 
8787  // If this is an explicit specialization of a member that is a function
8788  // template, mark it as a member specialization.
8789  if (IsExplicitSpecialization &&
8790  NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
8791  NewTemplateDecl->setMemberSpecialization();
8792  assert(OldTemplateDecl->isMemberSpecialization());
8793  // Explicit specializations of a member template do not inherit deleted
8794  // status from the parent member template that they are specializing.
8795  if (OldTemplateDecl->getTemplatedDecl()->isDeleted()) {
8796  FunctionDecl *const OldTemplatedDecl =
8797  OldTemplateDecl->getTemplatedDecl();
8798  assert(OldTemplatedDecl->getCanonicalDecl() == OldTemplatedDecl);
8799  OldTemplatedDecl->setDeletedAsWritten(false);
8800  }
8801  }
8802 
8803  } else {
8804  // This needs to happen first so that 'inline' propagates.
8805  NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
8806 
8807  if (isa<CXXMethodDecl>(NewFD))
8808  NewFD->setAccess(OldDecl->getAccess());
8809  }
8810  }
8811 
8812  // Semantic checking for this function declaration (in isolation).
8813 
8814  if (getLangOpts().CPlusPlus) {
8815  // C++-specific checks.
8816  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
8817  CheckConstructor(Constructor);
8818  } else if (CXXDestructorDecl *Destructor =
8819  dyn_cast<CXXDestructorDecl>(NewFD)) {
8820  CXXRecordDecl *Record = Destructor->getParent();
8821  QualType ClassType = Context.getTypeDeclType(Record);
8822 
8823  // FIXME: Shouldn't we be able to perform this check even when the class
8824  // type is dependent? Both gcc and edg can handle that.
8825  if (!ClassType->isDependentType()) {
8826  DeclarationName Name
8828  Context.getCanonicalType(ClassType));
8829  if (NewFD->getDeclName() != Name) {
8830  Diag(NewFD->getLocation(), diag::err_destructor_name);
8831  NewFD->setInvalidDecl();
8832  return Redeclaration;
8833  }
8834  }
8835  } else if (CXXConversionDecl *Conversion
8836  = dyn_cast<CXXConversionDecl>(NewFD)) {
8837  ActOnConversionDeclarator(Conversion);
8838  }
8839 
8840  // Find any virtual functions that this function overrides.
8841  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
8842  if (!Method->isFunctionTemplateSpecialization() &&
8843  !Method->getDescribedFunctionTemplate() &&
8844  Method->isCanonicalDecl()) {
8845  if (AddOverriddenMethods(Method->getParent(), Method)) {
8846  // If the function was marked as "static", we have a problem.
8847  if (NewFD->getStorageClass() == SC_Static) {
8848  ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
8849  }
8850  }
8851  }
8852 
8853  if (Method->isStatic())
8854  checkThisInStaticMemberFunctionType(Method);
8855  }
8856 
8857  // Extra checking for C++ overloaded operators (C++ [over.oper]).
8858  if (NewFD->isOverloadedOperator() &&
8859  CheckOverloadedOperatorDeclaration(NewFD)) {
8860  NewFD->setInvalidDecl();
8861  return Redeclaration;
8862  }
8863 
8864  // Extra checking for C++0x literal operators (C++0x [over.literal]).
8865  if (NewFD->getLiteralIdentifier() &&
8866  CheckLiteralOperatorDeclaration(NewFD)) {
8867  NewFD->setInvalidDecl();
8868  return Redeclaration;
8869  }
8870 
8871  // In C++, check default arguments now that we have merged decls. Unless
8872  // the lexical context is the class, because in this case this is done
8873  // during delayed parsing anyway.
8874  if (!CurContext->isRecord())
8875  CheckCXXDefaultArguments(NewFD);
8876 
8877  // If this function declares a builtin function, check the type of this
8878  // declaration against the expected type for the builtin.
8879  if (unsigned BuiltinID = NewFD->getBuiltinID()) {
8881  LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
8882  QualType T = Context.GetBuiltinType(BuiltinID, Error);
8883  if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
8884  // The type of this function differs from the type of the builtin,
8885  // so forget about the builtin entirely.
8887  }
8888  }
8889 
8890  // If this function is declared as being extern "C", then check to see if
8891  // the function returns a UDT (class, struct, or union type) that is not C
8892  // compatible, and if it does, warn the user.
8893  // But, issue any diagnostic on the first declaration only.
8894  if (Previous.empty() && NewFD->isExternC()) {
8895  QualType R = NewFD->getReturnType();
8896  if (R->isIncompleteType() && !R->isVoidType())
8897  Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
8898  << NewFD << R;
8899  else if (!R.isPODType(Context) && !R->isVoidType() &&
8901  Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
8902  }
8903  }
8904  return Redeclaration;
8905 }
8906 
8907 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
8908  // C++11 [basic.start.main]p3:
8909  // A program that [...] declares main to be inline, static or
8910  // constexpr is ill-formed.
8911  // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
8912  // appear in a declaration of main.
8913  // static main is not an error under C99, but we should warn about it.
8914  // We accept _Noreturn main as an extension.
8915  if (FD->getStorageClass() == SC_Static)
8916  Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
8917  ? diag::err_static_main : diag::warn_static_main)
8919  if (FD->isInlineSpecified())
8920  Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
8922  if (DS.isNoreturnSpecified()) {
8923  SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
8924  SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
8925  Diag(NoreturnLoc, diag::ext_noreturn_main);
8926  Diag(NoreturnLoc, diag::note_main_remove_noreturn)
8927  << FixItHint::CreateRemoval(NoreturnRange);
8928  }
8929  if (FD->isConstexpr()) {
8930  Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
8932  FD->setConstexpr(false);
8933  }
8934 
8935  if (getLangOpts().OpenCL) {
8936  Diag(FD->getLocation(), diag::err_opencl_no_main)
8937  << FD->hasAttr<OpenCLKernelAttr>();
8938  FD->setInvalidDecl();
8939  return;
8940  }
8941 
8942  QualType T = FD->getType();
8943  assert(T->isFunctionType() && "function decl is not of function type");
8944  const FunctionType* FT = T->castAs<FunctionType>();
8945 
8946  if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
8947  // In C with GNU extensions we allow main() to have non-integer return
8948  // type, but we should warn about the extension, and we disable the
8949  // implicit-return-zero rule.
8950 
8951  // GCC in C mode accepts qualified 'int'.
8952  if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
8953  FD->setHasImplicitReturnZero(true);
8954  else {
8955  Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
8956  SourceRange RTRange = FD->getReturnTypeSourceRange();
8957  if (RTRange.isValid())
8958  Diag(RTRange.getBegin(), diag::note_main_change_return_type)
8959  << FixItHint::CreateReplacement(RTRange, "int");
8960  }
8961  } else {
8962  // In C and C++, main magically returns 0 if you fall off the end;
8963  // set the flag which tells us that.
8964  // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
8965 
8966  // All the standards say that main() should return 'int'.
8967  if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
8968  FD->setHasImplicitReturnZero(true);
8969  else {
8970  // Otherwise, this is just a flat-out error.
8971  SourceRange RTRange = FD->getReturnTypeSourceRange();
8972  Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
8973  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
8974  : FixItHint());
8975  FD->setInvalidDecl(true);
8976  }
8977  }
8978 
8979  // Treat protoless main() as nullary.
8980  if (isa<FunctionNoProtoType>(FT)) return;
8981 
8982  const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
8983  unsigned nparams = FTP->getNumParams();
8984  assert(FD->getNumParams() == nparams);
8985 
8986  bool HasExtraParameters = (nparams > 3);
8987 
8988  if (FTP->isVariadic()) {
8989  Diag(FD->getLocation(), diag::ext_variadic_main);
8990  // FIXME: if we had information about the location of the ellipsis, we
8991  // could add a FixIt hint to remove it as a parameter.
8992  }
8993 
8994  // Darwin passes an undocumented fourth argument of type char**. If
8995  // other platforms start sprouting these, the logic below will start
8996  // getting shifty.
8997  if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
8998  HasExtraParameters = false;
8999 
9000  if (HasExtraParameters) {
9001  Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
9002  FD->setInvalidDecl(true);
9003  nparams = 3;
9004  }
9005 
9006  // FIXME: a lot of the following diagnostics would be improved
9007  // if we had some location information about types.
9008 
9009  QualType CharPP =
9011  QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
9012 
9013  for (unsigned i = 0; i < nparams; ++i) {
9014  QualType AT = FTP->getParamType(i);
9015 
9016  bool mismatch = true;
9017 
9018  if (Context.hasSameUnqualifiedType(AT, Expected[i]))
9019  mismatch = false;
9020  else if (Expected[i] == CharPP) {
9021  // As an extension, the following forms are okay:
9022  // char const **
9023  // char const * const *
9024  // char * const *
9025 
9026  QualifierCollector qs;
9027  const PointerType* PT;
9028  if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
9029  (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
9031  Context.CharTy)) {
9032  qs.removeConst();
9033  mismatch = !qs.empty();
9034  }
9035  }
9036 
9037  if (mismatch) {
9038  Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
9039  // TODO: suggest replacing given type with expected type
9040  FD->setInvalidDecl(true);
9041  }
9042  }
9043 
9044  if (nparams == 1 && !FD->isInvalidDecl()) {
9045  Diag(FD->getLocation(), diag::warn_main_one_arg);
9046  }
9047 
9048  if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
9049  Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
9050  FD->setInvalidDecl();
9051  }
9052 }
9053 
9055  QualType T = FD->getType();
9056  assert(T->isFunctionType() && "function decl is not of function type");
9057  const FunctionType *FT = T->castAs<FunctionType>();
9058 
9059  // Set an implicit return of 'zero' if the function can return some integral,
9060  // enumeration, pointer or nullptr type.
9061  if (FT->getReturnType()->isIntegralOrEnumerationType() ||
9062  FT->getReturnType()->isAnyPointerType() ||
9063  FT->getReturnType()->isNullPtrType())
9064  // DllMain is exempt because a return value of zero means it failed.
9065  if (FD->getName() != "DllMain")
9066  FD->setHasImplicitReturnZero(true);
9067 
9068  if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
9069  Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
9070  FD->setInvalidDecl();
9071  }
9072 }
9073 
9075  // FIXME: Need strict checking. In C89, we need to check for
9076  // any assignment, increment, decrement, function-calls, or
9077  // commas outside of a sizeof. In C99, it's the same list,
9078  // except that the aforementioned are allowed in unevaluated
9079  // expressions. Everything else falls under the
9080  // "may accept other forms of constant expressions" exception.
9081  // (We never end up here for C++, so the constant expression
9082  // rules there don't matter.)
9083  const Expr *Culprit;
9084  if (Init->isConstantInitializer(Context, false, &Culprit))
9085  return false;
9086  Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
9087  << Culprit->getSourceRange();
9088  return true;
9089 }
9090 
9091 namespace {
9092  // Visits an initialization expression to see if OrigDecl is evaluated in
9093  // its own initialization and throws a warning if it does.
9094  class SelfReferenceChecker
9095  : public EvaluatedExprVisitor<SelfReferenceChecker> {
9096  Sema &S;
9097  Decl *OrigDecl;
9098  bool isRecordType;
9099  bool isPODType;
9100  bool isReferenceType;
9101 
9102  bool isInitList;
9103  llvm::SmallVector<unsigned, 4> InitFieldIndex;
9104 
9105  public:
9107 
9108  SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
9109  S(S), OrigDecl(OrigDecl) {
9110  isPODType = false;
9111  isRecordType = false;
9112  isReferenceType = false;
9113  isInitList = false;
9114  if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
9115  isPODType = VD->getType().isPODType(S.Context);
9116  isRecordType = VD->getType()->isRecordType();
9117  isReferenceType = VD->getType()->isReferenceType();
9118  }
9119  }
9120 
9121  // For most expressions, just call the visitor. For initializer lists,
9122  // track the index of the field being initialized since fields are
9123  // initialized in order allowing use of previously initialized fields.
9124  void CheckExpr(Expr *E) {
9125  InitListExpr *InitList = dyn_cast<InitListExpr>(E);
9126  if (!InitList) {
9127  Visit(E);
9128  return;
9129  }
9130 
9131  // Track and increment the index here.
9132  isInitList = true;
9133  InitFieldIndex.push_back(0);
9134  for (auto Child : InitList->children()) {
9135  CheckExpr(cast<Expr>(Child));
9136  ++InitFieldIndex.back();
9137  }
9138  InitFieldIndex.pop_back();
9139  }
9140 
9141  // Returns true if MemberExpr is checked and no futher checking is needed.
9142  // Returns false if additional checking is required.
9143  bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
9145  Expr *Base = E;
9146  bool ReferenceField = false;
9147 
9148  // Get the field memebers used.
9149  while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
9150  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
9151  if (!FD)
9152  return false;
9153  Fields.push_back(FD);
9154  if (FD->getType()->isReferenceType())
9155  ReferenceField = true;
9156  Base = ME->getBase()->IgnoreParenImpCasts();
9157  }
9158 
9159  // Keep checking only if the base Decl is the same.
9160  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
9161  if (!DRE || DRE->getDecl() != OrigDecl)
9162  return false;
9163 
9164  // A reference field can be bound to an unininitialized field.
9165  if (CheckReference && !ReferenceField)
9166  return true;
9167 
9168  // Convert FieldDecls to their index number.
9169  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
9170  for (const FieldDecl *I : llvm::reverse(Fields))
9171  UsedFieldIndex.push_back(I->getFieldIndex());
9172 
9173  // See if a warning is needed by checking the first difference in index
9174  // numbers. If field being used has index less than the field being
9175  // initialized, then the use is safe.
9176  for (auto UsedIter = UsedFieldIndex.begin(),
9177  UsedEnd = UsedFieldIndex.end(),
9178  OrigIter = InitFieldIndex.begin(),
9179  OrigEnd = InitFieldIndex.end();
9180  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
9181  if (*UsedIter < *OrigIter)
9182  return true;
9183  if (*UsedIter > *OrigIter)
9184  break;
9185  }
9186 
9187  // TODO: Add a different warning which will print the field names.
9188  HandleDeclRefExpr(DRE);
9189  return true;
9190  }
9191 
9192  // For most expressions, the cast is directly above the DeclRefExpr.
9193  // For conditional operators, the cast can be outside the conditional
9194  // operator if both expressions are DeclRefExpr's.
9195  void HandleValue(Expr *E) {
9196  E = E->IgnoreParens();
9197  if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
9198  HandleDeclRefExpr(DRE);
9199  return;
9200  }
9201 
9202  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
9203  Visit(CO->getCond());
9204  HandleValue(CO->getTrueExpr());
9205  HandleValue(CO->getFalseExpr());
9206  return;
9207  }
9208 
9209  if (BinaryConditionalOperator *BCO =
9210  dyn_cast<BinaryConditionalOperator>(E)) {
9211  Visit(BCO->getCond());
9212  HandleValue(BCO->getFalseExpr());
9213  return;
9214  }
9215 
9216  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
9217  HandleValue(OVE->getSourceExpr());
9218  return;
9219  }
9220 
9221  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
9222  if (BO->getOpcode() == BO_Comma) {
9223  Visit(BO->getLHS());
9224  HandleValue(BO->getRHS());
9225  return;
9226  }
9227  }
9228 
9229  if (isa<MemberExpr>(E)) {
9230  if (isInitList) {
9231  if (CheckInitListMemberExpr(cast<MemberExpr>(E),
9232  false /*CheckReference*/))
9233  return;
9234  }
9235 
9236  Expr *Base = E->IgnoreParenImpCasts();
9237  while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
9238  // Check for static member variables and don't warn on them.
9239  if (!isa<FieldDecl>(ME->getMemberDecl()))
9240  return;
9241  Base = ME->getBase()->IgnoreParenImpCasts();
9242  }
9243  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
9244  HandleDeclRefExpr(DRE);
9245  return;
9246  }
9247 
9248  Visit(E);
9249  }
9250 
9251  // Reference types not handled in HandleValue are handled here since all
9252  // uses of references are bad, not just r-value uses.
9253  void VisitDeclRefExpr(DeclRefExpr *E) {
9254  if (isReferenceType)
9255  HandleDeclRefExpr(E);
9256  }
9257 
9258  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
9259  if (E->getCastKind() == CK_LValueToRValue) {
9260  HandleValue(E->getSubExpr());
9261  return;
9262  }
9263 
9264  Inherited::VisitImplicitCastExpr(E);
9265  }
9266 
9267  void VisitMemberExpr(MemberExpr *E) {
9268  if (isInitList) {
9269  if (CheckInitListMemberExpr(E, true /*CheckReference*/))
9270  return;
9271  }
9272 
9273  // Don't warn on arrays since they can be treated as pointers.
9274  if (E->getType()->canDecayToPointerType()) return;
9275 
9276  // Warn when a non-static method call is followed by non-static member
9277  // field accesses, which is followed by a DeclRefExpr.
9278  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
9279  bool Warn = (MD && !MD->isStatic());
9280  Expr *Base = E->getBase()->IgnoreParenImpCasts();
9281  while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
9282  if (!isa<FieldDecl>(ME->getMemberDecl()))
9283  Warn = false;
9284  Base = ME->getBase()->IgnoreParenImpCasts();
9285  }
9286 
9287  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
9288  if (Warn)
9289  HandleDeclRefExpr(DRE);
9290  return;
9291  }
9292 
9293  // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
9294  // Visit that expression.
9295  Visit(Base);
9296  }
9297 
9298  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
9299  Expr *Callee = E->getCallee();
9300 
9301  if (isa<UnresolvedLookupExpr>(Callee))
9302  return Inherited::VisitCXXOperatorCallExpr(E);
9303 
9304  Visit(Callee);
9305  for (auto Arg: E->arguments())
9306  HandleValue(Arg->IgnoreParenImpCasts());
9307  }
9308 
9309  void VisitUnaryOperator(UnaryOperator *E) {
9310  // For POD record types, addresses of its own members are well-defined.
9311  if (E->getOpcode() == UO_AddrOf && isRecordType &&
9312  isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
9313  if (!isPODType)
9314  HandleValue(E->getSubExpr());
9315  return;
9316  }
9317 
9318  if (E->isIncrementDecrementOp()) {
9319  HandleValue(E->getSubExpr());
9320  return;
9321  }
9322 
9323  Inherited::VisitUnaryOperator(E);
9324  }
9325 
9326  void VisitObjCMessageExpr(ObjCMessageExpr *E) {}
9327 
9328  void VisitCXXConstructExpr(CXXConstructExpr *E) {
9329  if (E->getConstructor()->isCopyConstructor()) {
9330  Expr *ArgExpr = E->getArg(0);
9331  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
9332  if (ILE->getNumInits() == 1)
9333  ArgExpr = ILE->getInit(0);
9334  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
9335  if (ICE->getCastKind() == CK_NoOp)
9336  ArgExpr = ICE->getSubExpr();
9337  HandleValue(ArgExpr);
9338  return;
9339  }
9340  Inherited::VisitCXXConstructExpr(E);
9341  }
9342 
9343  void VisitCallExpr(CallExpr *E) {
9344  // Treat std::move as a use.
9345  if (E->getNumArgs() == 1) {
9346  if (FunctionDecl *FD = E->getDirectCallee()) {
9347  if (FD->isInStdNamespace() && FD->getIdentifier() &&
9348  FD->getIdentifier()->isStr("move")) {
9349  HandleValue(E->getArg(0));
9350  return;
9351  }
9352  }
9353  }
9354 
9355  Inherited::VisitCallExpr(E);
9356  }
9357 
9358  void VisitBinaryOperator(BinaryOperator *E) {
9359  if (E->isCompoundAssignmentOp()) {
9360  HandleValue(E->getLHS());
9361  Visit(E->getRHS());
9362  return;
9363  }
9364 
9365  Inherited::VisitBinaryOperator(E);
9366  }
9367 
9368  // A custom visitor for BinaryConditionalOperator is needed because the
9369  // regular visitor would check the condition and true expression separately
9370  // but both point to the same place giving duplicate diagnostics.
9371  void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
9372  Visit(E->getCond());
9373  Visit(E->getFalseExpr());
9374  }
9375 
9376  void HandleDeclRefExpr(DeclRefExpr *DRE) {
9377  Decl* ReferenceDecl = DRE->getDecl();
9378  if (OrigDecl != ReferenceDecl) return;
9379  unsigned diag;
9380  if (isReferenceType) {
9381  diag = diag::warn_uninit_self_reference_in_reference_init;
9382  } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
9383  diag = diag::warn_static_self_reference_in_init;
9384  } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) ||
9385  isa<NamespaceDecl>(OrigDecl->getDeclContext()) ||
9386  DRE->getDecl()->getType()->isRecordType()) {
9387  diag = diag::warn_uninit_self_reference_in_init;
9388  } else {
9389  // Local variables will be handled by the CFG analysis.
9390  return;
9391  }
9392 
9393  S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
9394  S.PDiag(diag)
9395  << DRE->getNameInfo().getName()
9396  << OrigDecl->getLocation()
9397  << DRE->getSourceRange());
9398  }
9399  };
9400 
9401  /// CheckSelfReference - Warns if OrigDecl is used in expression E.
9402  static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
9403  bool DirectInit) {
9404  // Parameters arguments are occassionially constructed with itself,
9405  // for instance, in recursive functions. Skip them.
9406  if (isa<ParmVarDecl>(OrigDecl))
9407  return;
9408 
9409  E = E->IgnoreParens();
9410 
9411  // Skip checking T a = a where T is not a record or reference type.
9412  // Doing so is a way to silence uninitialized warnings.
9413  if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
9414  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
9415  if (ICE->getCastKind() == CK_LValueToRValue)
9416  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
9417  if (DRE->getDecl() == OrigDecl)
9418  return;
9419 
9420  SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
9421  }
9422 } // end anonymous namespace
9423 
9426  TypeSourceInfo *TSI,
9427  SourceRange Range, bool DirectInit,
9428  Expr *Init) {
9429  bool IsInitCapture = !VDecl;
9430  assert((!VDecl || !VDecl->isInitCapture()) &&
9431  "init captures are expected to be deduced prior to initialization");
9432 
9433  ArrayRef<Expr *> DeduceInits = Init;
9434  if (DirectInit) {
9435  if (auto *PL = dyn_cast<ParenListExpr>(Init))
9436  DeduceInits = PL->exprs();
9437  else if (auto *IL = dyn_cast<InitListExpr>(Init))
9438  DeduceInits = IL->inits();
9439  }
9440 
9441  // Deduction only works if we have exactly one source expression.
9442  if (DeduceInits.empty()) {
9443  // It isn't possible to write this directly, but it is possible to
9444  // end up in this situation with "auto x(some_pack...);"
9445  Diag(Init->getLocStart(), IsInitCapture
9446  ? diag::err_init_capture_no_expression
9447  : diag::err_auto_var_init_no_expression)
9448  << Name << Type << Range;
9449  return QualType();
9450  }
9451 
9452  if (DeduceInits.size() > 1) {
9453  Diag(DeduceInits[1]->getLocStart(),
9454  IsInitCapture ? diag::err_init_capture_multiple_expressions
9455  : diag::err_auto_var_init_multiple_expressions)
9456  << Name << Type << Range;
9457  return QualType();
9458  }
9459 
9460  Expr *DeduceInit = DeduceInits[0];
9461  if (DirectInit && isa<InitListExpr>(DeduceInit)) {
9462  Diag(Init->getLocStart(), IsInitCapture
9463  ? diag::err_init_capture_paren_braces
9464  : diag::err_auto_var_init_paren_braces)
9465  << isa<InitListExpr>(Init) << Name << Type << Range;
9466  return QualType();
9467  }
9468 
9469  // Expressions default to 'id' when we're in a debugger.
9470  bool DefaultedAnyToId = false;
9471  if (getLangOpts().DebuggerCastResultToId &&
9472  Init->getType() == Context.UnknownAnyTy && !IsInitCapture) {
9473  ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
9474  if (Result.isInvalid()) {
9475  return QualType();
9476  }
9477  Init = Result.get();
9478  DefaultedAnyToId = true;
9479  }
9480 
9481  QualType DeducedType;
9482  if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
9483  if (!IsInitCapture)
9484  DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
9485  else if (isa<InitListExpr>(Init))
9486  Diag(Range.getBegin(),
9487  diag::err_init_capture_deduction_failure_from_init_list)
9488  << Name
9489  << (DeduceInit->getType().isNull() ? TSI->getType()
9490  : DeduceInit->getType())
9491  << DeduceInit->getSourceRange();
9492  else
9493  Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
9494  << Name << TSI->getType()
9495  << (DeduceInit->getType().isNull() ? TSI->getType()
9496  : DeduceInit->getType())
9497  << DeduceInit->getSourceRange();
9498  }
9499 
9500  // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
9501  // 'id' instead of a specific object type prevents most of our usual
9502  // checks.
9503  // We only want to warn outside of template instantiations, though:
9504  // inside a template, the 'id' could have come from a parameter.
9505  if (ActiveTemplateInstantiations.empty() && !DefaultedAnyToId &&
9506  !IsInitCapture && !DeducedType.isNull() && DeducedType->isObjCIdType()) {
9507  SourceLocation Loc = TSI->getTypeLoc().getBeginLoc();
9508  Diag(Loc, diag::warn_auto_var_is_id) << Name << Range;
9509  }
9510 
9511  return DeducedType;
9512 }
9513 
9514 /// AddInitializerToDecl - Adds the initializer Init to the
9515 /// declaration dcl. If DirectInit is true, this is C++ direct
9516 /// initialization rather than copy initialization.
9517 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
9518  bool DirectInit, bool TypeMayContainAuto) {
9519  // If there is no declaration, there was an error parsing it. Just ignore
9520  // the initializer.
9521  if (!RealDecl || RealDecl->isInvalidDecl()) {
9522  CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl));
9523  return;
9524  }
9525 
9526  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
9527  // Pure-specifiers are handled in ActOnPureSpecifier.
9528  Diag(Method->getLocation(), diag::err_member_function_initialization)
9529  << Method->getDeclName() << Init->getSourceRange();
9530  Method->setInvalidDecl();
9531  return;
9532  }
9533 
9534  VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
9535  if (!VDecl) {
9536  assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
9537  Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
9538  RealDecl->setInvalidDecl();
9539  return;
9540  }
9541 
9542  // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
9543  if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
9544  // Attempt typo correction early so that the type of the init expression can
9545  // be deduced based on the chosen correction if the original init contains a
9546  // TypoExpr.
9547  ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
9548  if (!Res.isUsable()) {
9549  RealDecl->setInvalidDecl();
9550  return;
9551  }
9552  Init = Res.get();
9553 
9554  QualType DeducedType = deduceVarTypeFromInitializer(
9555  VDecl, VDecl->getDeclName(), VDecl->getType(),
9556  VDecl->getTypeSourceInfo(), VDecl->getSourceRange(), DirectInit, Init);
9557  if (DeducedType.isNull()) {
9558  RealDecl->setInvalidDecl();
9559  return;
9560  }
9561 
9562  VDecl->setType(DeducedType);
9563  assert(VDecl->isLinkageValid());
9564 
9565  // In ARC, infer lifetime.
9566  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
9567  VDecl->setInvalidDecl();
9568 
9569  // If this is a redeclaration, check that the type we just deduced matches
9570  // the previously declared type.
9571  if (VarDecl *Old = VDecl->getPreviousDecl()) {
9572  // We never need to merge the type, because we cannot form an incomplete
9573  // array of auto, nor deduce such a type.
9574  MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/ false);
9575  }
9576 
9577  // Check the deduced type is valid for a variable declaration.
9578  CheckVariableDeclarationType(VDecl);
9579  if (VDecl->isInvalidDecl())
9580  return;
9581  }
9582 
9583  // dllimport cannot be used on variable definitions.
9584  if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
9585  Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
9586  VDecl->setInvalidDecl();
9587  return;
9588  }
9589 
9590  if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
9591  // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
9592  Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
9593  VDecl->setInvalidDecl();
9594  return;
9595  }
9596 
9597  if (!VDecl->getType()->isDependentType()) {
9598  // A definition must end up with a complete type, which means it must be
9599  // complete with the restriction that an array type might be completed by
9600  // the initializer; note that later code assumes this restriction.
9601  QualType BaseDeclType = VDecl->getType();
9602  if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
9603  BaseDeclType = Array->getElementType();
9604  if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
9605  diag::err_typecheck_decl_incomplete_type)) {
9606  RealDecl->setInvalidDecl();
9607  return;
9608  }
9609 
9610  // The variable can not have an abstract class type.
9611  if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
9612  diag::err_abstract_type_in_decl,
9613  AbstractVariableType))
9614  VDecl->setInvalidDecl();
9615  }
9616 
9617  VarDecl *Def;
9618  if ((Def = VDecl->getDefinition()) && Def != VDecl) {
9619  NamedDecl *Hidden = nullptr;
9620  if (!hasVisibleDefinition(Def, &Hidden) &&
9621  (VDecl->getFormalLinkage() == InternalLinkage ||
9622  VDecl->getDescribedVarTemplate() ||
9623  VDecl->getNumTemplateParameterLists() ||
9624  VDecl->getDeclContext()->isDependentContext())) {
9625  // The previous definition is hidden, and multiple definitions are
9626  // permitted (in separate TUs). Form another definition of it.
9627  } else {
9628  Diag(VDecl->getLocation(), diag::err_redefinition)
9629  << VDecl->getDeclName();
9630  Diag(Def->getLocation(), diag::note_previous_definition);
9631  VDecl->setInvalidDecl();
9632  return;
9633  }
9634  }
9635 
9636  if (getLangOpts().CPlusPlus) {
9637  // C++ [class.static.data]p4
9638  // If a static data member is of const integral or const
9639  // enumeration type, its declaration in the class definition can
9640  // specify a constant-initializer which shall be an integral
9641  // constant expression (5.19). In that case, the member can appear
9642  // in integral constant expressions. The member shall still be
9643  // defined in a namespace scope if it is used in the program and the
9644  // namespace scope definition shall not contain an initializer.
9645  //
9646  // We already performed a redefinition check above, but for static
9647  // data members we also need to check whether there was an in-class
9648  // declaration with an initializer.
9649  if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {
9650  Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
9651  << VDecl->getDeclName();
9652  Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(),
9653  diag::note_previous_initializer)
9654  << 0;
9655  return;
9656  }
9657 
9658  if (VDecl->hasLocalStorage())
9659  getCurFunction()->setHasBranchProtectedScope();
9660 
9661  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
9662  VDecl->setInvalidDecl();
9663  return;
9664  }
9665  }
9666 
9667  // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
9668  // a kernel function cannot be initialized."
9669  if (VDecl->getType().getAddressSpace() == LangAS::opencl_local) {
9670  Diag(VDecl->getLocation(), diag::err_local_cant_init);
9671  VDecl->setInvalidDecl();
9672  return;
9673  }
9674 
9675  // Get the decls type and save a reference for later, since
9676  // CheckInitializerTypes may change it.
9677  QualType DclT = VDecl->getType(), SavT = DclT;
9678 
9679  // Expressions default to 'id' when we're in a debugger
9680  // and we are assigning it to a variable of Objective-C pointer type.
9681  if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
9682  Init->getType() == Context.UnknownAnyTy) {
9683  ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
9684  if (Result.isInvalid()) {
9685  VDecl->setInvalidDecl();
9686  return;
9687  }
9688  Init = Result.get();
9689  }
9690 
9691  // Perform the initialization.
9692  ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
9693  if (!VDecl->isInvalidDecl()) {
9696  DirectInit
9697  ? CXXDirectInit
9698  ? InitializationKind::CreateDirect(VDecl->getLocation(),
9699  Init->getLocStart(),
9700  Init->getLocEnd())
9701  : InitializationKind::CreateDirectList(VDecl->getLocation())
9702  : InitializationKind::CreateCopy(VDecl->getLocation(),
9703  Init->getLocStart());
9704 
9705  MultiExprArg Args = Init;
9706  if (CXXDirectInit)
9707  Args = MultiExprArg(CXXDirectInit->getExprs(),
9708  CXXDirectInit->getNumExprs());
9709 
9710  // Try to correct any TypoExprs in the initialization arguments.
9711  for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
9712  ExprResult Res = CorrectDelayedTyposInExpr(
9713  Args[Idx], VDecl, [this, Entity, Kind](Expr *E) {
9714  InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
9715  return Init.Failed() ? ExprError() : E;
9716  });
9717  if (Res.isInvalid()) {
9718  VDecl->setInvalidDecl();
9719  } else if (Res.get() != Args[Idx]) {
9720  Args[Idx] = Res.get();
9721  }
9722  }
9723  if (VDecl->isInvalidDecl())
9724  return;
9725 
9726  InitializationSequence InitSeq(*this, Entity, Kind, Args,
9727  /*TopLevelOfInitList=*/false,
9728  /*TreatUnavailableAsInvalid=*/false);
9729  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
9730  if (Result.isInvalid()) {
9731  VDecl->setInvalidDecl();
9732  return;
9733  }
9734 
9735  Init = Result.getAs<Expr>();
9736  }
9737 
9738  // Check for self-references within variable initializers.
9739  // Variables declared within a function/method body (except for references)
9740  // are handled by a dataflow analysis.
9741  if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
9742  VDecl->getType()->isReferenceType()) {
9743  CheckSelfReference(*this, RealDecl, Init, DirectInit);
9744  }
9745 
9746  // If the type changed, it means we had an incomplete type that was
9747  // completed by the initializer. For example:
9748  // int ary[] = { 1, 3, 5 };
9749  // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
9750  if (!VDecl->isInvalidDecl() && (DclT != SavT))
9751  VDecl->setType(DclT);
9752 
9753  if (!VDecl->isInvalidDecl()) {
9754  checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
9755 
9756  if (VDecl->hasAttr<BlocksAttr>())
9757  checkRetainCycles(VDecl, Init);
9758 
9759  // It is safe to assign a weak reference into a strong variable.
9760  // Although this code can still have problems:
9761  // id x = self.weakProp;
9762  // id y = self.weakProp;
9763  // we do not warn to warn spuriously when 'x' and 'y' are on separate
9764  // paths through the function. This should be revisited if
9765  // -Wrepeated-use-of-weak is made flow-sensitive.
9766  if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong &&
9767  !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
9768  Init->getLocStart()))
9769  getCurFunction()->markSafeWeakUse(Init);
9770  }
9771 
9772  // The initialization is usually a full-expression.
9773  //
9774  // FIXME: If this is a braced initialization of an aggregate, it is not
9775  // an expression, and each individual field initializer is a separate
9776  // full-expression. For instance, in:
9777  //
9778  // struct Temp { ~Temp(); };
9779  // struct S { S(Temp); };
9780  // struct T { S a, b; } t = { Temp(), Temp() }
9781  //
9782  // we should destroy the first Temp before constructing the second.
9783  ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
9784  false,
9785  VDecl->isConstexpr());
9786  if (Result.isInvalid()) {
9787  VDecl->setInvalidDecl();
9788  return;
9789  }
9790  Init = Result.get();
9791 
9792  // Attach the initializer to the decl.
9793  VDecl->setInit(Init);
9794 
9795  if (VDecl->isLocalVarDecl()) {
9796  // C99 6.7.8p4: All the expressions in an initializer for an object that has
9797  // static storage duration shall be constant expressions or string literals.
9798  // C++ does not have this restriction.
9799  if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) {
9800  const Expr *Culprit;
9801  if (VDecl->getStorageClass() == SC_Static)
9802  CheckForConstantInitializer(Init, DclT);
9803  // C89 is stricter than C99 for non-static aggregate types.
9804  // C89 6.5.7p3: All the expressions [...] in an initializer list
9805  // for an object that has aggregate or union type shall be
9806  // constant expressions.
9807  else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
9808  isa<InitListExpr>(Init) &&
9809  !Init->isConstantInitializer(Context, false, &Culprit))
9810  Diag(Culprit->getExprLoc(),
9811  diag::ext_aggregate_init_not_constant)
9812  << Culprit->getSourceRange();
9813  }
9814  } else if (VDecl->isStaticDataMember() && !VDecl->isInline() &&
9815  VDecl->getLexicalDeclContext()->isRecord()) {
9816  // This is an in-class initialization for a static data member, e.g.,
9817  //
9818  // struct S {
9819  // static const int value = 17;
9820  // };
9821 
9822  // C++ [class.mem]p4:
9823  // A member-declarator can contain a constant-initializer only
9824  // if it declares a static member (9.4) of const integral or
9825  // const enumeration type, see 9.4.2.
9826  //
9827  // C++11 [class.static.data]p3:
9828  // If a non-volatile non-inline const static data member is of integral
9829  // or enumeration type, its declaration in the class definition can
9830  // specify a brace-or-equal-initializer in which every initalizer-clause
9831  // that is an assignment-expression is a constant expression. A static
9832  // data member of literal type can be declared in the class definition
9833  // with the constexpr specifier; if so, its declaration shall specify a
9834  // brace-or-equal-initializer in which every initializer-clause that is
9835  // an assignment-expression is a constant expression.
9836 
9837  // Do nothing on dependent types.
9838  if (DclT->isDependentType()) {
9839 
9840  // Allow any 'static constexpr' members, whether or not they are of literal
9841  // type. We separately check that every constexpr variable is of literal
9842  // type.
9843  } else if (VDecl->isConstexpr()) {
9844 
9845  // Require constness.
9846  } else if (!DclT.isConstQualified()) {
9847  Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
9848  << Init->getSourceRange();
9849  VDecl->setInvalidDecl();
9850 
9851  // We allow integer constant expressions in all cases.
9852  } else if (DclT->isIntegralOrEnumerationType()) {
9853  // Check whether the expression is a constant expression.
9854  SourceLocation Loc;
9855  if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
9856  // In C++11, a non-constexpr const static data member with an
9857  // in-class initializer cannot be volatile.
9858  Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
9859  else if (Init->isValueDependent())
9860  ; // Nothing to check.
9861  else if (Init->isIntegerConstantExpr(Context, &Loc))
9862  ; // Ok, it's an ICE!
9863  else if (Init->isEvaluatable(Context)) {
9864  // If we can constant fold the initializer through heroics, accept it,
9865  // but report this as a use of an extension for -pedantic.
9866  Diag(Loc, diag::ext_in_class_initializer_non_constant)
9867  << Init->getSourceRange();
9868  } else {
9869  // Otherwise, this is some crazy unknown case. Report the issue at the
9870  // location provided by the isIntegerConstantExpr failed check.
9871  Diag(Loc, diag::err_in_class_initializer_non_constant)
9872  << Init->getSourceRange();
9873  VDecl->setInvalidDecl();
9874  }
9875 
9876  // We allow foldable floating-point constants as an extension.
9877  } else if (DclT->isFloatingType()) { // also permits complex, which is ok
9878  // In C++98, this is a GNU extension. In C++11, it is not, but we support
9879  // it anyway and provide a fixit to add the 'constexpr'.
9880  if (getLangOpts().CPlusPlus11) {
9881  Diag(VDecl->getLocation(),
9882  diag::ext_in_class_initializer_float_type_cxx11)
9883  << DclT << Init->getSourceRange();
9884  Diag(VDecl->getLocStart(),
9885  diag::note_in_class_initializer_float_type_cxx11)
9886  << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
9887  } else {
9888  Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
9889  << DclT << Init->getSourceRange();
9890 
9891  if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
9892  Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
9893  << Init->getSourceRange();
9894  VDecl->setInvalidDecl();
9895  }
9896  }
9897 
9898  // Suggest adding 'constexpr' in C++11 for literal types.
9899  } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
9900  Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
9901  << DclT << Init->getSourceRange()
9902  << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
9903  VDecl->setConstexpr(true);
9904 
9905  } else {
9906  Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
9907  << DclT << Init->getSourceRange();
9908  VDecl->setInvalidDecl();
9909  }
9910  } else if (VDecl->isFileVarDecl()) {
9911  if (VDecl->getStorageClass() == SC_Extern &&
9912  (!getLangOpts().CPlusPlus ||
9913  !(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
9914  VDecl->isExternC())) &&
9916  Diag(VDecl->getLocation(), diag::warn_extern_init);
9917 
9918  // C99 6.7.8p4. All file scoped initializers need to be constant.
9919  if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
9920  CheckForConstantInitializer(Init, DclT);
9921  }
9922 
9923  // We will represent direct-initialization similarly to copy-initialization:
9924  // int x(1); -as-> int x = 1;
9925  // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
9926  //
9927  // Clients that want to distinguish between the two forms, can check for
9928  // direct initializer using VarDecl::getInitStyle().
9929  // A major benefit is that clients that don't particularly care about which
9930  // exactly form was it (like the CodeGen) can handle both cases without
9931  // special case code.
9932 
9933  // C++ 8.5p11:
9934  // The form of initialization (using parentheses or '=') is generally
9935  // insignificant, but does matter when the entity being initialized has a
9936  // class type.
9937  if (CXXDirectInit) {
9938  assert(DirectInit && "Call-style initializer must be direct init.");
9940  } else if (DirectInit) {
9941  // This must be list-initialization. No other way is direct-initialization.
9943  }
9944 
9945  CheckCompleteVariableDeclaration(VDecl);
9946 }
9947 
9948 /// ActOnInitializerError - Given that there was an error parsing an
9949 /// initializer for the given declaration, try to return to some form
9950 /// of sanity.
9952  // Our main concern here is re-establishing invariants like "a
9953  // variable's type is either dependent or complete".
9954  if (!D || D->isInvalidDecl()) return;
9955 
9956  VarDecl *VD = dyn_cast<VarDecl>(D);
9957  if (!VD) return;
9958 
9959  // Auto types are meaningless if we can't make sense of the initializer.
9960  if (ParsingInitForAutoVars.count(D)) {
9961  D->setInvalidDecl();
9962  return;
9963  }
9964 
9965  QualType Ty = VD->getType();
9966  if (Ty->isDependentType()) return;
9967 
9968  // Require a complete type.
9969  if (RequireCompleteType(VD->getLocation(),
9971  diag::err_typecheck_decl_incomplete_type)) {
9972  VD->setInvalidDecl();
9973  return;
9974  }
9975 
9976  // Require a non-abstract type.
9977  if (RequireNonAbstractType(VD->getLocation(), Ty,
9978  diag::err_abstract_type_in_decl,
9979  AbstractVariableType)) {
9980  VD->setInvalidDecl();
9981  return;
9982  }
9983 
9984  // Don't bother complaining about constructors or destructors,
9985  // though.
9986 }
9987 
9989  bool TypeMayContainAuto) {
9990  // If there is no declaration, there was an error parsing it. Just ignore it.
9991  if (!RealDecl)
9992  return;
9993 
9994  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
9995  QualType Type = Var->getType();
9996 
9997  // C++11 [dcl.spec.auto]p3
9998  if (TypeMayContainAuto && Type->getContainedAutoType()) {
9999  Diag(Var->getLocation(), diag::err_auto_var_requires_init)
10000  << Var->getDeclName() << Type;
10001  Var->setInvalidDecl();
10002  return;
10003  }
10004 
10005  // C++11 [class.static.data]p3: A static data member can be declared with
10006  // the constexpr specifier; if so, its declaration shall specify
10007  // a brace-or-equal-initializer.
10008  // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
10009  // the definition of a variable [...] or the declaration of a static data
10010  // member.
10011  if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
10012  if (Var->isStaticDataMember()) {
10013  // C++1z removes the relevant rule; the in-class declaration is always
10014  // a definition there.
10015  if (!getLangOpts().CPlusPlus1z) {
10016  Diag(Var->getLocation(),
10017  diag::err_constexpr_static_mem_var_requires_init)
10018  << Var->getDeclName();
10019  Var->setInvalidDecl();
10020  return;
10021  }
10022  } else {
10023  Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
10024  Var->setInvalidDecl();
10025  return;
10026  }
10027  }
10028 
10029  // C++ Concepts TS [dcl.spec.concept]p1: [...] A variable template
10030  // definition having the concept specifier is called a variable concept. A
10031  // concept definition refers to [...] a variable concept and its initializer.
10032  if (VarTemplateDecl *VTD = Var->getDescribedVarTemplate()) {
10033  if (VTD->isConcept()) {
10034  Diag(Var->getLocation(), diag::err_var_concept_not_initialized);
10035  Var->setInvalidDecl();
10036  return;
10037  }
10038  }
10039 
10040  // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
10041  // be initialized.
10042  if (!Var->isInvalidDecl() &&
10043  Var->getType().getAddressSpace() == LangAS::opencl_constant &&
10044  Var->getStorageClass() != SC_Extern && !Var->getInit()) {
10045  Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
10046  Var->setInvalidDecl();
10047  return;
10048  }
10049 
10050  switch (Var->isThisDeclarationADefinition()) {
10051  case VarDecl::Definition:
10052  if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
10053  break;
10054 
10055  // We have an out-of-line definition of a static data member
10056  // that has an in-class initializer, so we type-check this like
10057  // a declaration.
10058  //
10059  // Fall through
10060 
10062  // It's only a declaration.
10063 
10064  // Block scope. C99 6.7p7: If an identifier for an object is
10065  // declared with no linkage (C99 6.2.2p6), the type for the
10066  // object shall be complete.
10067  if (!Type->isDependentType() && Var->isLocalVarDecl() &&
10068  !Var->hasLinkage() && !Var->isInvalidDecl() &&
10069  RequireCompleteType(Var->getLocation(), Type,
10070  diag::err_typecheck_decl_incomplete_type))
10071  Var->setInvalidDecl();
10072 
10073  // Make sure that the type is not abstract.
10074  if (!Type->isDependentType() && !Var->isInvalidDecl() &&
10075  RequireNonAbstractType(Var->getLocation(), Type,
10076  diag::err_abstract_type_in_decl,
10077  AbstractVariableType))
10078  Var->setInvalidDecl();
10079  if (!Type->isDependentType() && !Var->isInvalidDecl() &&
10080  Var->getStorageClass() == SC_PrivateExtern) {
10081  Diag(Var->getLocation(), diag::warn_private_extern);
10082  Diag(Var->getLocation(), diag::note_private_extern);
10083  }
10084 
10085  return;
10086 
10088  // File scope. C99 6.9.2p2: A declaration of an identifier for an
10089  // object that has file scope without an initializer, and without a
10090  // storage-class specifier or with the storage-class specifier "static",
10091  // constitutes a tentative definition. Note: A tentative definition with
10092  // external linkage is valid (C99 6.2.2p5).
10093  if (!Var->isInvalidDecl()) {
10094  if (const IncompleteArrayType *ArrayT
10096  if (RequireCompleteType(Var->getLocation(),
10097  ArrayT->getElementType(),
10098  diag::err_illegal_decl_array_incomplete_type))
10099  Var->setInvalidDecl();
10100  } else if (Var->getStorageClass() == SC_Static) {
10101  // C99 6.9.2p3: If the declaration of an identifier for an object is
10102  // a tentative definition and has internal linkage (C99 6.2.2p3), the
10103  // declared type shall not be an incomplete type.
10104  // NOTE: code such as the following
10105  // static struct s;
10106  // struct s { int a; };
10107  // is accepted by gcc. Hence here we issue a warning instead of
10108  // an error and we do not invalidate the static declaration.
10109  // NOTE: to avoid multiple warnings, only check the first declaration.
10110  if (Var->isFirstDecl())
10111  RequireCompleteType(Var->getLocation(), Type,
10112  diag::ext_typecheck_decl_incomplete_type);
10113  }
10114  }
10115 
10116  // Record the tentative definition; we're done.
10117  if (!Var->isInvalidDecl())
10118  TentativeDefinitions.push_back(Var);
10119  return;
10120  }
10121 
10122  // Provide a specific diagnostic for uninitialized variable
10123  // definitions with incomplete array type.
10124  if (Type->isIncompleteArrayType()) {
10125  Diag(Var->getLocation(),
10126  diag::err_typecheck_incomplete_array_needs_initializer);
10127  Var->setInvalidDecl();
10128  return;
10129  }
10130 
10131  // Provide a specific diagnostic for uninitialized variable
10132  // definitions with reference type.
10133  if (Type->isReferenceType()) {
10134  Diag(Var->getLocation(), diag::err_reference_var_requires_init)
10135  << Var->getDeclName()
10136  << SourceRange(Var->getLocation(), Var->getLocation());
10137  Var->setInvalidDecl();
10138  return;
10139  }
10140 
10141  // Do not attempt to type-check the default initializer for a
10142  // variable with dependent type.
10143  if (Type->isDependentType())
10144  return;
10145 
10146  if (Var->isInvalidDecl())
10147  return;
10148 
10149  if (!Var->hasAttr<AliasAttr>()) {
10150  if (RequireCompleteType(Var->getLocation(),
10152  diag::err_typecheck_decl_incomplete_type)) {
10153  Var->setInvalidDecl();
10154  return;
10155  }
10156  } else {
10157  return;
10158  }
10159 
10160  // The variable can not have an abstract class type.
10161  if (RequireNonAbstractType(Var->getLocation(), Type,
10162  diag::err_abstract_type_in_decl,
10163  AbstractVariableType)) {
10164  Var->setInvalidDecl();
10165  return;
10166  }
10167 
10168  // Check for jumps past the implicit initializer. C++0x
10169  // clarifies that this applies to a "variable with automatic
10170  // storage duration", not a "local variable".
10171  // C++11 [stmt.dcl]p3
10172  // A program that jumps from a point where a variable with automatic
10173  // storage duration is not in scope to a point where it is in scope is
10174  // ill-formed unless the variable has scalar type, class type with a
10175  // trivial default constructor and a trivial destructor, a cv-qualified
10176  // version of one of these types, or an array of one of the preceding
10177  // types and is declared without an initializer.
10178  if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
10179  if (const RecordType *Record
10181  CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
10182  // Mark the function for further checking even if the looser rules of
10183  // C++11 do not require such checks, so that we can diagnose
10184  // incompatibilities with C++98.
10185  if (!CXXRecord->isPOD())
10186  getCurFunction()->setHasBranchProtectedScope();
10187  }
10188  }
10189 
10190  // C++03 [dcl.init]p9:
10191  // If no initializer is specified for an object, and the
10192  // object is of (possibly cv-qualified) non-POD class type (or
10193  // array thereof), the object shall be default-initialized; if
10194  // the object is of const-qualified type, the underlying class
10195  // type shall have a user-declared default
10196  // constructor. Otherwise, if no initializer is specified for
10197  // a non- static object, the object and its subobjects, if
10198  // any, have an indeterminate initial value); if the object
10199  // or any of its subobjects are of const-qualified type, the
10200  // program is ill-formed.
10201  // C++0x [dcl.init]p11:
10202  // If no initializer is specified for an object, the object is
10203  // default-initialized; [...].
10206  = InitializationKind::CreateDefault(Var->getLocation());
10207 
10208  InitializationSequence InitSeq(*this, Entity, Kind, None);
10209  ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
10210  if (Init.isInvalid())
10211  Var->setInvalidDecl();
10212  else if (Init.get()) {
10213  Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
10214  // This is important for template substitution.
10215  Var->setInitStyle(VarDecl::CallInit);
10216  }
10217 
10218  CheckCompleteVariableDeclaration(Var);
10219  }
10220 }
10221 
10223  // If there is no declaration, there was an error parsing it. Ignore it.
10224  if (!D)
10225  return;
10226 
10227  VarDecl *VD = dyn_cast<VarDecl>(D);
10228  if (!VD) {
10229  Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
10230  D->setInvalidDecl();
10231  return;
10232  }
10233 
10234  VD->setCXXForRangeDecl(true);
10235 
10236  // for-range-declaration cannot be given a storage class specifier.
10237  int Error = -1;
10238  switch (VD->getStorageClass()) {
10239  case SC_None:
10240  break;
10241  case SC_Extern:
10242  Error = 0;
10243  break;
10244  case SC_Static:
10245  Error = 1;
10246  break;
10247  case SC_PrivateExtern:
10248  Error = 2;
10249  break;
10250  case SC_Auto:
10251  Error = 3;
10252  break;
10253  case SC_Register:
10254  Error = 4;
10255  break;
10256  }
10257  if (Error != -1) {
10258  Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
10259  << VD->getDeclName() << Error;
10260  D->setInvalidDecl();
10261  }
10262 }
10263 
10264 StmtResult
10266  IdentifierInfo *Ident,
10267  ParsedAttributes &Attrs,
10268  SourceLocation AttrEnd) {
10269  // C++1y [stmt.iter]p1:
10270  // A range-based for statement of the form
10271  // for ( for-range-identifier : for-range-initializer ) statement
10272  // is equivalent to
10273  // for ( auto&& for-range-identifier : for-range-initializer ) statement
10274  DeclSpec DS(Attrs.getPool().getFactory());
10275 
10276  const char *PrevSpec;
10277  unsigned DiagID;
10278  DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
10279  getPrintingPolicy());
10280 
10282  D.SetIdentifier(Ident, IdentLoc);
10283  D.takeAttributes(Attrs, AttrEnd);
10284 
10285  ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
10286  D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false),
10287  EmptyAttrs, IdentLoc);
10288  Decl *Var = ActOnDeclarator(S, D);
10289  cast<VarDecl>(Var)->setCXXForRangeDecl(true);
10290  FinalizeDeclaration(Var);
10291  return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
10292  AttrEnd.isValid() ? AttrEnd : IdentLoc);
10293 }
10294 
10296  if (var->isInvalidDecl()) return;
10297 
10298  if (getLangOpts().OpenCL) {
10299  // OpenCL v2.0 s6.12.5 - Every block variable declaration must have an
10300  // initialiser
10301  if (var->getTypeSourceInfo()->getType()->isBlockPointerType() &&
10302  !var->hasInit()) {
10303  Diag(var->getLocation(), diag::err_opencl_invalid_block_declaration)
10304  << 1 /*Init*/;
10305  var->setInvalidDecl();
10306  return;
10307  }
10308  }
10309 
10310  // In Objective-C, don't allow jumps past the implicit initialization of a
10311  // local retaining variable.
10312  if (getLangOpts().ObjC1 &&
10313  var->hasLocalStorage()) {
10314  switch (var->getType().getObjCLifetime()) {
10315  case Qualifiers::OCL_None:
10318  break;
10319 
10320  case Qualifiers::OCL_Weak:
10322  getCurFunction()->setHasBranchProtectedScope();
10323  break;
10324  }
10325  }
10326 
10327  // Warn about externally-visible variables being defined without a
10328  // prior declaration. We only want to do this for global
10329  // declarations, but we also specifically need to avoid doing it for
10330  // class members because the linkage of an anonymous class can
10331  // change if it's later given a typedef name.
10332  if (var->isThisDeclarationADefinition() &&
10333  var->getDeclContext()->getRedeclContext()->isFileContext() &&
10334  var->isExternallyVisible() && var->hasLinkage() &&
10335  !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
10336  var->getLocation())) {
10337  // Find a previous declaration that's not a definition.
10338  VarDecl *prev = var->getPreviousDecl();
10339  while (prev && prev->isThisDeclarationADefinition())
10340  prev = prev->getPreviousDecl();
10341 
10342  if (!prev)
10343  Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
10344  }
10345 
10346  if (var->getTLSKind() == VarDecl::TLS_Static) {
10347  const Expr *Culprit;
10348  if (var->getType().isDestructedType()) {
10349  // GNU C++98 edits for __thread, [basic.start.term]p3:
10350  // The type of an object with thread storage duration shall not
10351  // have a non-trivial destructor.
10352  Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
10353  if (getLangOpts().CPlusPlus11)
10354  Diag(var->getLocation(), diag::note_use_thread_local);
10355  } else if (getLangOpts().CPlusPlus && var->hasInit() &&
10356  !var->getInit()->isConstantInitializer(
10357  Context, var->getType()->isReferenceType(), &Culprit)) {
10358  // GNU C++98 edits for __thread, [basic.start.init]p4:
10359  // An object of thread storage duration shall not require dynamic
10360  // initialization.
10361  // FIXME: Need strict checking here.
10362  Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init)
10363  << Culprit->getSourceRange();
10364  if (getLangOpts().CPlusPlus11)
10365  Diag(var->getLocation(), diag::note_use_thread_local);
10366  }
10367  }
10368 
10369  // Apply section attributes and pragmas to global variables.
10370  bool GlobalStorage = var->hasGlobalStorage();
10371  if (GlobalStorage && var->isThisDeclarationADefinition() &&
10372  ActiveTemplateInstantiations.empty()) {
10374  int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read;
10375  if (var->getType().isConstQualified())
10376  Stack = &ConstSegStack;
10377  else if (!var->getInit()) {
10378  Stack = &BSSSegStack;
10379  SectionFlags |= ASTContext::PSF_Write;
10380  } else {
10381  Stack = &DataSegStack;
10382  SectionFlags |= ASTContext::PSF_Write;
10383  }
10384  if (Stack->CurrentValue && !var->hasAttr<SectionAttr>()) {
10385  var->addAttr(SectionAttr::CreateImplicit(
10386  Context, SectionAttr::Declspec_allocate,
10387  Stack->CurrentValue->getString(), Stack->CurrentPragmaLocation));
10388  }
10389  if (const SectionAttr *SA = var->getAttr<SectionAttr>())
10390  if (UnifySection(SA->getName(), SectionFlags, var))
10391  var->dropAttr<SectionAttr>();
10392 
10393  // Apply the init_seg attribute if this has an initializer. If the
10394  // initializer turns out to not be dynamic, we'll end up ignoring this
10395  // attribute.
10396  if (CurInitSeg && var->getInit())
10397  var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
10398  CurInitSegLoc));
10399  }
10400 
10401  // All the following checks are C++ only.
10402  if (!getLangOpts().CPlusPlus) return;
10403 
10404  QualType type = var->getType();
10405  if (type->isDependentType()) return;
10406 
10407  // __block variables might require us to capture a copy-initializer.
10408  if (var->hasAttr<BlocksAttr>()) {
10409  // It's currently invalid to ever have a __block variable with an
10410  // array type; should we diagnose that here?
10411 
10412  // Regardless, we don't want to ignore array nesting when
10413  // constructing this copy.
10414  if (type->isStructureOrClassType()) {
10415  EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
10416  SourceLocation poi = var->getLocation();
10417  Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
10418  ExprResult result
10419  = PerformMoveOrCopyInitialization(
10420  InitializedEntity::InitializeBlock(poi, type, false),
10421  var, var->getType(), varRef, /*AllowNRVO=*/true);
10422  if (!result.isInvalid()) {
10423  result = MaybeCreateExprWithCleanups(result);
10424  Expr *init = result.getAs<Expr>();
10425  Context.setBlockVarCopyInits(var, init);
10426  }
10427  }
10428  }
10429 
10430  Expr *Init = var->getInit();
10431  bool IsGlobal = GlobalStorage && !var->isStaticLocal();
10432  QualType baseType = Context.getBaseElementType(type);
10433 
10434  if (!var->getDeclContext()->isDependentContext() &&
10435  Init && !Init->isValueDependent()) {
10436  if (IsGlobal && !var->isConstexpr() &&
10437  !getDiagnostics().isIgnored(diag::warn_global_constructor,
10438  var->getLocation())) {
10439  // Warn about globals which don't have a constant initializer. Don't
10440  // warn about globals with a non-trivial destructor because we already
10441  // warned about them.
10442  CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
10443  if (!(RD && !RD->hasTrivialDestructor()) &&
10444  !Init->isConstantInitializer(Context, baseType->isReferenceType()))
10445  Diag(var->getLocation(), diag::warn_global_constructor)
10446  << Init->getSourceRange();
10447  }
10448 
10449  if (var->isConstexpr()) {
10451  if (!var->evaluateValue(Notes) || !var->isInitICE()) {
10452  SourceLocation DiagLoc = var->getLocation();
10453  // If the note doesn't add any useful information other than a source
10454  // location, fold it into the primary diagnostic.
10455  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
10456  diag::note_invalid_subexpr_in_const_expr) {
10457  DiagLoc = Notes[0].first;
10458  Notes.clear();
10459  }
10460  Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
10461  << var << Init->getSourceRange();
10462  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
10463  Diag(Notes[I].first, Notes[I].second);
10464  }
10465  } else if (var->isUsableInConstantExpressions(Context)) {
10466  // Check whether the initializer of a const variable of integral or
10467  // enumeration type is an ICE now, since we can't tell whether it was
10468  // initialized by a constant expression if we check later.
10469  var->checkInitIsICE();
10470  }
10471  }
10472 
10473  // Require the destructor.
10474  if (const RecordType *recordType = baseType->getAs<RecordType>())
10475  FinalizeVarWithDestructor(var, recordType);
10476 }
10477 
10478 /// \brief Determines if a variable's alignment is dependent.
10479 static bool hasDependentAlignment(VarDecl *VD) {
10480  if (VD->getType()->isDependentType())
10481  return true;
10482  for (auto *I : VD->specific_attrs<AlignedAttr>())
10483  if (I->isAlignmentDependent())
10484  return true;
10485  return false;
10486 }
10487 
10488 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
10489 /// any semantic actions necessary after any initializer has been attached.
10490 void
10492  // Note that we are no longer parsing the initializer for this declaration.
10493  ParsingInitForAutoVars.erase(ThisDecl);
10494 
10495  VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
10496  if (!VD)
10497  return;
10498 
10499  checkAttributesAfterMerging(*this, *VD);
10500 
10501  // Perform TLS alignment check here after attributes attached to the variable
10502  // which may affect the alignment have been processed. Only perform the check
10503  // if the target has a maximum TLS alignment (zero means no constraints).
10504  if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) {
10505  // Protect the check so that it's not performed on dependent types and
10506  // dependent alignments (we can't determine the alignment in that case).
10507  if (VD->getTLSKind() && !hasDependentAlignment(VD)) {
10508  CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
10509  if (Context.getDeclAlign(VD) > MaxAlignChars) {
10510  Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
10511  << (unsigned)Context.getDeclAlign(VD).getQuantity() << VD
10512  << (unsigned)MaxAlignChars.getQuantity();
10513  }
10514  }
10515  }
10516 
10517  if (VD->isStaticLocal()) {
10518  if (FunctionDecl *FD =
10519  dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
10520  // Static locals inherit dll attributes from their function.
10521  if (Attr *A = getDLLAttr(FD)) {
10522  auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
10523  NewAttr->setInherited(true);
10524  VD->addAttr(NewAttr);
10525  }
10526  // CUDA E.2.9.4: Within the body of a __device__ or __global__
10527  // function, only __shared__ variables may be declared with
10528  // static storage class.
10529  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
10530  (FD->hasAttr<CUDADeviceAttr>() || FD->hasAttr<CUDAGlobalAttr>()) &&
10531  !VD->hasAttr<CUDASharedAttr>()) {
10532  Diag(VD->getLocation(), diag::err_device_static_local_var);
10533  VD->setInvalidDecl();
10534  }
10535  }
10536  }
10537 
10538  // Perform check for initializers of device-side global variables.
10539  // CUDA allows empty constructors as initializers (see E.2.3.1, CUDA
10540  // 7.5). We must also apply the same checks to all __shared__
10541  // variables whether they are local or not. CUDA also allows
10542  // constant initializers for __constant__ and __device__ variables.
10543  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
10544  const Expr *Init = VD->getInit();
10545  if (Init && VD->hasGlobalStorage() &&
10546  (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>() ||
10547  VD->hasAttr<CUDASharedAttr>())) {
10548  assert((!VD->isStaticLocal() || VD->hasAttr<CUDASharedAttr>()));
10549  bool AllowedInit = false;
10550  if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init))
10551  AllowedInit =
10552  isEmptyCudaConstructor(VD->getLocation(), CE->getConstructor());
10553  // We'll allow constant initializers even if it's a non-empty
10554  // constructor according to CUDA rules. This deviates from NVCC,
10555  // but allows us to handle things like constexpr constructors.
10556  if (!AllowedInit &&
10557  (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>()))
10558  AllowedInit = VD->getInit()->isConstantInitializer(
10559  Context, VD->getType()->isReferenceType());
10560 
10561  // Also make sure that destructor, if there is one, is empty.
10562  if (AllowedInit)
10563  if (CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl())
10564  AllowedInit =
10565  isEmptyCudaDestructor(VD->getLocation(), RD->getDestructor());
10566 
10567  if (!AllowedInit) {
10568  Diag(VD->getLocation(), VD->hasAttr<CUDASharedAttr>()
10569  ? diag::err_shared_var_init
10570  : diag::err_dynamic_var_init)
10571  << Init->getSourceRange();
10572  VD->setInvalidDecl();
10573  }
10574  }
10575  }
10576 
10577  // Grab the dllimport or dllexport attribute off of the VarDecl.
10578  const InheritableAttr *DLLAttr = getDLLAttr(VD);
10579 
10580  // Imported static data members cannot be defined out-of-line.
10581  if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
10582  if (VD->isStaticDataMember() && VD->isOutOfLine() &&
10584  // We allow definitions of dllimport class template static data members
10585  // with a warning.
10587  cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
10588  bool IsClassTemplateMember =
10589  isa<ClassTemplatePartialSpecializationDecl>(Context) ||
10590  Context->getDescribedClassTemplate();
10591 
10592  Diag(VD->getLocation(),
10593  IsClassTemplateMember
10594  ? diag::warn_attribute_dllimport_static_field_definition
10595  : diag::err_attribute_dllimport_static_field_definition);
10596  Diag(IA->getLocation(), diag::note_attribute);
10597  if (!IsClassTemplateMember)
10598  VD->setInvalidDecl();
10599  }
10600  }
10601 
10602  // dllimport/dllexport variables cannot be thread local, their TLS index
10603  // isn't exported with the variable.
10604  if (DLLAttr && VD->getTLSKind()) {
10605  auto *F = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
10606  if (F && getDLLAttr(F)) {
10607  assert(VD->isStaticLocal());
10608  // But if this is a static local in a dlimport/dllexport function, the
10609  // function will never be inlined, which means the var would never be
10610  // imported, so having it marked import/export is safe.
10611  } else {
10612  Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
10613  << DLLAttr;
10614  VD->setInvalidDecl();
10615  }
10616  }
10617 
10618  if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
10619  if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
10620  Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
10621  VD->dropAttr<UsedAttr>();
10622  }
10623  }
10624 
10625  const DeclContext *DC = VD->getDeclContext();
10626  // If there's a #pragma GCC visibility in scope, and this isn't a class
10627  // member, set the visibility of this variable.
10628  if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
10629  AddPushedVisibilityAttribute(VD);
10630 
10631  // FIXME: Warn on unused templates.
10632  if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() &&
10633  !isa<VarTemplatePartialSpecializationDecl>(VD))
10634  MarkUnusedFileScopedDecl(VD);
10635 
10636  // Now we have parsed the initializer and can update the table of magic
10637  // tag values.
10638  if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
10640  return;
10641 
10642  for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
10643  const Expr *MagicValueExpr = VD->getInit();
10644  if (!MagicValueExpr) {
10645  continue;
10646  }
10647  llvm::APSInt MagicValueInt;
10648  if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
10649  Diag(I->getRange().getBegin(),
10650  diag::err_type_tag_for_datatype_not_ice)
10651  << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
10652  continue;
10653  }
10654  if (MagicValueInt.getActiveBits() > 64) {
10655  Diag(I->getRange().getBegin(),
10656  diag::err_type_tag_for_datatype_too_large)
10657  << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
10658  continue;
10659  }
10660  uint64_t MagicValue = MagicValueInt.getZExtValue();
10661  RegisterTypeTagForDatatype(I->getArgumentKind(),
10662  MagicValue,
10663  I->getMatchingCType(),
10664  I->getLayoutCompatible(),
10665  I->getMustBeNull());
10666  }
10667 }
10668 
10670  ArrayRef<Decl *> Group) {
10671  SmallVector<Decl*, 8> Decls;
10672 
10673  if (DS.isTypeSpecOwned())
10674  Decls.push_back(DS.getRepAsDecl());
10675 
10676  DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
10677  for (unsigned i = 0, e = Group.size(); i != e; ++i)
10678  if (Decl *D = Group[i]) {
10679  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
10680  if (!FirstDeclaratorInGroup)
10681  FirstDeclaratorInGroup = DD;
10682  Decls.push_back(D);
10683  }
10684 
10686  if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
10687  handleTagNumbering(Tag, S);
10688  if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
10689  getLangOpts().CPlusPlus)
10690  Context.addDeclaratorForUnnamedTagDecl(Tag, FirstDeclaratorInGroup);
10691  }
10692  }
10693 
10694  return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType());
10695 }
10696 
10697 /// BuildDeclaratorGroup - convert a list of declarations into a declaration
10698 /// group, performing any necessary semantic checking.
10701  bool TypeMayContainAuto) {
10702  // C++0x [dcl.spec.auto]p7:
10703  // If the type deduced for the template parameter U is not the same in each
10704  // deduction, the program is ill-formed.
10705  // FIXME: When initializer-list support is added, a distinction is needed
10706  // between the deduced type U and the deduced type which 'auto' stands for.
10707  // auto a = 0, b = { 1, 2, 3 };
10708  // is legal because the deduced type U is 'int' in both cases.
10709  if (TypeMayContainAuto && Group.size() > 1) {
10710  QualType Deduced;
10711  CanQualType DeducedCanon;
10712  VarDecl *DeducedDecl = nullptr;
10713  for (unsigned i = 0, e = Group.size(); i != e; ++i) {
10714  if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
10715  AutoType *AT = D->getType()->getContainedAutoType();
10716  // Don't reissue diagnostics when instantiating a template.
10717  if (AT && D->isInvalidDecl())
10718  break;
10719  QualType U = AT ? AT->getDeducedType() : QualType();
10720  if (!U.isNull()) {
10721  CanQualType UCanon = Context.getCanonicalType(U);
10722  if (Deduced.isNull()) {
10723  Deduced = U;
10724  DeducedCanon = UCanon;
10725  DeducedDecl = D;
10726  } else if (DeducedCanon != UCanon) {
10727  Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
10728  diag::err_auto_different_deductions)
10729  << (unsigned)AT->getKeyword()
10730  << Deduced << DeducedDecl->getDeclName()
10731  << U << D->getDeclName()
10732  << DeducedDecl->getInit()->getSourceRange()
10733  << D->getInit()->getSourceRange();
10734  D->setInvalidDecl();
10735  break;
10736  }
10737  }
10738  }
10739  }
10740  }
10741 
10742  ActOnDocumentableDecls(Group);
10743 
10744  return DeclGroupPtrTy::make(
10745  DeclGroupRef::Create(Context, Group.data(), Group.size()));
10746 }
10747 
10749  ActOnDocumentableDecls(D);
10750 }
10751 
10753  // Don't parse the comment if Doxygen diagnostics are ignored.
10754  if (Group.empty() || !Group[0])
10755  return;
10756 
10757  if (Diags.isIgnored(diag::warn_doc_param_not_found,
10758  Group[0]->getLocation()) &&
10759  Diags.isIgnored(diag::warn_unknown_comment_command_name,
10760  Group[0]->getLocation()))
10761  return;
10762 
10763  if (Group.size() >= 2) {
10764  // This is a decl group. Normally it will contain only declarations
10765  // produced from declarator list. But in case we have any definitions or
10766  // additional declaration references:
10767  // 'typedef struct S {} S;'
10768  // 'typedef struct S *S;'
10769  // 'struct S *pS;'
10770  // FinalizeDeclaratorGroup adds these as separate declarations.
10771  Decl *MaybeTagDecl = Group[0];
10772  if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
10773  Group = Group.slice(1);
10774  }
10775  }
10776 
10777  // See if there are any new comments that are not attached to a decl.
10779  if (!Comments.empty() &&
10780  !Comments.back()->isAttached()) {
10781  // There is at least one comment that not attached to a decl.
10782  // Maybe it should be attached to one of these decls?
10783  //
10784  // Note that this way we pick up not only comments that precede the
10785  // declaration, but also comments that *follow* the declaration -- thanks to
10786  // the lookahead in the lexer: we've consumed the semicolon and looked
10787  // ahead through comments.
10788  for (unsigned i = 0, e = Group.size(); i != e; ++i)
10789  Context.getCommentForDecl(Group[i], &PP);
10790  }
10791 }
10792 
10793 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
10794 /// to introduce parameters into function prototype scope.
10796  const DeclSpec &DS = D.getDeclSpec();
10797 
10798  // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
10799 
10800  // C++03 [dcl.stc]p2 also permits 'auto'.
10801  StorageClass SC = SC_None;
10803  SC = SC_Register;
10804  } else if (getLangOpts().CPlusPlus &&
10806  SC = SC_Auto;
10807  } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
10809  diag::err_invalid_storage_class_in_func_decl);
10811  }
10812 
10813  if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
10814  Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
10815  << DeclSpec::getSpecifierName(TSCS);
10816  if (DS.isInlineSpecified())
10817  Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
10818  << getLangOpts().CPlusPlus1z;
10819  if (DS.isConstexprSpecified())
10820  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
10821  << 0;
10822  if (DS.isConceptSpecified())
10823  Diag(DS.getConceptSpecLoc(), diag::err_concept_wrong_decl_kind);
10824 
10825  DiagnoseFunctionSpecifiers(DS);
10826 
10827  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
10828  QualType parmDeclType = TInfo->getType();
10829 
10830  if (getLangOpts().CPlusPlus) {
10831  // Check that there are no default arguments inside the type of this
10832  // parameter.
10833  CheckExtraCXXDefaultArguments(D);
10834 
10835  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
10836  if (D.getCXXScopeSpec().isSet()) {
10837  Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
10838  << D.getCXXScopeSpec().getRange();
10839  D.getCXXScopeSpec().clear();
10840  }
10841  }
10842 
10843  // Ensure we have a valid name
10844  IdentifierInfo *II = nullptr;
10845  if (D.hasName()) {
10846  II = D.getIdentifier();
10847  if (!II) {
10848  Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
10849  << GetNameForDeclarator(D).getName();
10850  D.setInvalidType(true);
10851  }
10852  }
10853 
10854  // Check for redeclaration of parameters, e.g. int foo(int x, int x);
10855  if (II) {
10856  LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
10857  ForRedeclaration);
10858  LookupName(R, S);
10859  if (R.isSingleResult()) {
10860  NamedDecl *PrevDecl = R.getFoundDecl();
10861  if (PrevDecl->isTemplateParameter()) {
10862  // Maybe we will complain about the shadowed template parameter.
10863  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
10864  // Just pretend that we didn't see the previous declaration.
10865  PrevDecl = nullptr;
10866  } else if (S->isDeclScope(PrevDecl)) {
10867  Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
10868  Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
10869 
10870  // Recover by removing the name
10871  II = nullptr;
10872  D.SetIdentifier(nullptr, D.getIdentifierLoc());
10873  D.setInvalidType(true);
10874  }
10875  }
10876  }
10877 
10878  // Temporarily put parameter variables in the translation unit, not
10879  // the enclosing context. This prevents them from accidentally
10880  // looking like class members in C++.
10881  ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
10882  D.getLocStart(),
10883  D.getIdentifierLoc(), II,
10884  parmDeclType, TInfo,
10885  SC);
10886 
10887  if (D.isInvalidType())
10888  New->setInvalidDecl();
10889 
10890  assert(S->isFunctionPrototypeScope());
10891  assert(S->getFunctionPrototypeDepth() >= 1);
10894 
10895  // Add the parameter declaration into this scope.
10896  S->AddDecl(New);
10897  if (II)
10898  IdResolver.AddDecl(New);
10899 
10900  ProcessDeclAttributes(S, New, D);
10901 
10903  Diag(New->getLocation(), diag::err_module_private_local)
10904  << 1 << New->getDeclName()
10907 
10908  if (New->hasAttr<BlocksAttr>()) {
10909  Diag(New->getLocation(), diag::err_block_on_nonlocal);
10910  }
10911  return New;
10912 }
10913 
10914 /// \brief Synthesizes a variable for a parameter arising from a
10915 /// typedef.
10917  SourceLocation Loc,
10918  QualType T) {
10919  /* FIXME: setting StartLoc == Loc.
10920  Would it be worth to modify callers so as to provide proper source
10921  location for the unnamed parameters, embedding the parameter's type? */
10922  ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
10923  T, Context.getTrivialTypeSourceInfo(T, Loc),
10924  SC_None, nullptr);
10925  Param->setImplicit();
10926  return Param;
10927 }
10928 
10930  // Don't diagnose unused-parameter errors in template instantiations; we
10931  // will already have done so in the template itself.
10932  if (!ActiveTemplateInstantiations.empty())
10933  return;
10934 
10935  for (const ParmVarDecl *Parameter : Parameters) {
10936  if (!Parameter->isReferenced() && Parameter->getDeclName() &&
10937  !Parameter->hasAttr<UnusedAttr>()) {
10938  Diag(Parameter->getLocation(), diag::warn_unused_parameter)
10939  << Parameter->getDeclName();
10940  }
10941  }
10942 }
10943 
10945  ArrayRef<ParmVarDecl *> Parameters, QualType ReturnTy, NamedDecl *D) {
10946  if (LangOpts.NumLargeByValueCopy == 0) // No check.
10947  return;
10948 
10949  // Warn if the return value is pass-by-value and larger than the specified
10950  // threshold.
10951  if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
10952  unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
10953  if (Size > LangOpts.NumLargeByValueCopy)
10954  Diag(D->getLocation(), diag::warn_return_value_size)
10955  << D->getDeclName() << Size;
10956  }
10957 
10958  // Warn if any parameter is pass-by-value and larger than the specified
10959  // threshold.
10960  for (const ParmVarDecl *Parameter : Parameters) {
10961  QualType T = Parameter->getType();
10962  if (T->isDependentType() || !T.isPODType(Context))
10963  continue;
10964  unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
10965  if (Size > LangOpts.NumLargeByValueCopy)
10966  Diag(Parameter->getLocation(), diag::warn_parameter_size)
10967  << Parameter->getDeclName() << Size;
10968  }
10969 }
10970 
10972  SourceLocation NameLoc, IdentifierInfo *Name,
10973  QualType T, TypeSourceInfo *TSInfo,
10974  StorageClass SC) {
10975  // In ARC, infer a lifetime qualifier for appropriate parameter types.
10976  if (getLangOpts().ObjCAutoRefCount &&
10978  T->isObjCLifetimeType()) {
10979 
10980  Qualifiers::ObjCLifetime lifetime;
10981 
10982  // Special cases for arrays:
10983  // - if it's const, use __unsafe_unretained
10984  // - otherwise, it's an error
10985  if (T->isArrayType()) {
10986  if (!T.isConstQualified()) {
10989  NameLoc, diag::err_arc_array_param_no_ownership, T, false));
10990  }
10991  lifetime = Qualifiers::OCL_ExplicitNone;
10992  } else {
10993  lifetime = T->getObjCARCImplicitLifetime();
10994  }
10995  T = Context.getLifetimeQualifiedType(T, lifetime);
10996  }
10997 
10998  ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
11000  TSInfo, SC, nullptr);
11001 
11002  // Parameters can not be abstract class types.
11003  // For record types, this is done by the AbstractClassUsageDiagnoser once
11004  // the class has been completely parsed.
11005  if (!CurContext->isRecord() &&
11006  RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
11007  AbstractParamType))
11008  New->setInvalidDecl();
11009 
11010  // Parameter declarators cannot be interface types. All ObjC objects are
11011  // passed by reference.
11012  if (T->isObjCObjectType()) {
11013  SourceLocation TypeEndLoc =
11014  getLocForEndOfToken(TSInfo->getTypeLoc().getLocEnd());
11015  Diag(NameLoc,
11016  diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
11017  << FixItHint::CreateInsertion(TypeEndLoc, "*");
11019  New->setType(T);
11020  }
11021 
11022  // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
11023  // duration shall not be qualified by an address-space qualifier."
11024  // Since all parameters have automatic store duration, they can not have
11025  // an address space.
11026  if (T.getAddressSpace() != 0) {
11027  // OpenCL allows function arguments declared to be an array of a type
11028  // to be qualified with an address space.
11029  if (!(getLangOpts().OpenCL && T->isArrayType())) {
11030  Diag(NameLoc, diag::err_arg_with_address_space);
11031  New->setInvalidDecl();
11032  }
11033  }
11034 
11035  return New;
11036 }
11037 
11039  SourceLocation LocAfterDecls) {
11041 
11042  // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
11043  // for a K&R function.
11044  if (!FTI.hasPrototype) {
11045  for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
11046  --i;
11047  if (FTI.Params[i].Param == nullptr) {
11048  SmallString<256> Code;
11049  llvm::raw_svector_ostream(Code)
11050  << " int " << FTI.Params[i].Ident->getName() << ";\n";
11051  Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
11052  << FTI.Params[i].Ident
11053  << FixItHint::CreateInsertion(LocAfterDecls, Code);
11054 
11055  // Implicitly declare the argument as type 'int' for lack of a better
11056  // type.
11057  AttributeFactory attrs;
11058  DeclSpec DS(attrs);
11059  const char* PrevSpec; // unused
11060  unsigned DiagID; // unused
11061  DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
11062  DiagID, Context.getPrintingPolicy());
11063  // Use the identifier location for the type source range.
11064  DS.SetRangeStart(FTI.Params[i].IdentLoc);
11065  DS.SetRangeEnd(FTI.Params[i].IdentLoc);
11067  ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
11068  FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
11069  }
11070  }
11071  }
11072 }
11073 
11074 Decl *
11076  MultiTemplateParamsArg TemplateParameterLists,
11077  SkipBodyInfo *SkipBody) {
11078  assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
11079  assert(D.isFunctionDeclarator() && "Not a function declarator!");
11080  Scope *ParentScope = FnBodyScope->getParent();
11081 
11083  Decl *DP = HandleDeclarator(ParentScope, D, TemplateParameterLists);
11084  return ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody);
11085 }
11086 
11088  Consumer.HandleInlineFunctionDefinition(D);
11089 }
11090 
11092  const FunctionDecl*& PossibleZeroParamPrototype) {
11093  // Don't warn about invalid declarations.
11094  if (FD->isInvalidDecl())
11095  return false;
11096 
11097  // Or declarations that aren't global.
11098  if (!FD->isGlobal())
11099  return false;
11100 
11101  // Don't warn about C++ member functions.
11102  if (isa<CXXMethodDecl>(FD))
11103  return false;
11104 
11105  // Don't warn about 'main'.
11106  if (FD->isMain())
11107  return false;
11108 
11109  // Don't warn about inline functions.
11110  if (FD->isInlined())
11111  return false;
11112 
11113  // Don't warn about function templates.
11114  if (FD->getDescribedFunctionTemplate())
11115  return false;
11116 
11117  // Don't warn about function template specializations.
11119  return false;
11120 
11121  // Don't warn for OpenCL kernels.
11122  if (FD->hasAttr<OpenCLKernelAttr>())
11123  return false;
11124 
11125  // Don't warn on explicitly deleted functions.
11126  if (FD->isDeleted())
11127  return false;
11128 
11129  bool MissingPrototype = true;
11130  for (const FunctionDecl *Prev = FD->getPreviousDecl();
11131  Prev; Prev = Prev->getPreviousDecl()) {
11132  // Ignore any declarations that occur in function or method
11133  // scope, because they aren't visible from the header.
11134  if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
11135  continue;
11136 
11137  MissingPrototype = !Prev->getType()->isFunctionProtoType();
11138  if (FD->getNumParams() == 0)
11139  PossibleZeroParamPrototype = Prev;
11140  break;
11141  }
11142 
11143  return MissingPrototype;
11144 }
11145 
11146 void
11148  const FunctionDecl *EffectiveDefinition,
11149  SkipBodyInfo *SkipBody) {
11150  // Don't complain if we're in GNU89 mode and the previous definition
11151  // was an extern inline function.
11152  const FunctionDecl *Definition = EffectiveDefinition;
11153  if (!Definition)
11154  if (!FD->isDefined(Definition))
11155  return;
11156 
11157  if (canRedefineFunction(Definition, getLangOpts()))
11158  return;
11159 
11160  // If we don't have a visible definition of the function, and it's inline or
11161  // a template, skip the new definition.
11162  if (SkipBody && !hasVisibleDefinition(Definition) &&
11163  (Definition->getFormalLinkage() == InternalLinkage ||
11164  Definition->isInlined() ||
11165  Definition->getDescribedFunctionTemplate() ||
11166  Definition->getNumTemplateParameterLists())) {
11167  SkipBody->ShouldSkip = true;
11168  if (auto *TD = Definition->getDescribedFunctionTemplate())
11169  makeMergedDefinitionVisible(TD, FD->getLocation());
11170  else
11171  makeMergedDefinitionVisible(const_cast<FunctionDecl*>(Definition),
11172  FD->getLocation());
11173  return;
11174  }
11175 
11176  if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
11177  Definition->getStorageClass() == SC_Extern)
11178  Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
11179  << FD->getDeclName() << getLangOpts().CPlusPlus;
11180  else
11181  Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
11182 
11183  Diag(Definition->getLocation(), diag::note_previous_definition);
11184  FD->setInvalidDecl();
11185 }
11186 
11187 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
11188  Sema &S) {
11189  CXXRecordDecl *const LambdaClass = CallOperator->getParent();
11190 
11191  LambdaScopeInfo *LSI = S.PushLambdaScope();
11192  LSI->CallOperator = CallOperator;
11193  LSI->Lambda = LambdaClass;
11194  LSI->ReturnType = CallOperator->getReturnType();
11195  const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
11196 
11197  if (LCD == LCD_None)
11199  else if (LCD == LCD_ByCopy)
11201  else if (LCD == LCD_ByRef)
11203  DeclarationNameInfo DNI = CallOperator->getNameInfo();
11204 
11206  LSI->Mutable = !CallOperator->isConst();
11207 
11208  // Add the captures to the LSI so they can be noted as already
11209  // captured within tryCaptureVar.
11210  auto I = LambdaClass->field_begin();
11211  for (const auto &C : LambdaClass->captures()) {
11212  if (C.capturesVariable()) {
11213  VarDecl *VD = C.getCapturedVar();
11214  if (VD->isInitCapture())
11216  QualType CaptureType = VD->getType();
11217  const bool ByRef = C.getCaptureKind() == LCK_ByRef;
11218  LSI->addCapture(VD, /*IsBlock*/false, ByRef,
11219  /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
11220  /*EllipsisLoc*/C.isPackExpansion()
11221  ? C.getEllipsisLoc() : SourceLocation(),
11222  CaptureType, /*Expr*/ nullptr);
11223 
11224  } else if (C.capturesThis()) {
11225  LSI->addThisCapture(/*Nested*/ false, C.getLocation(),
11226  /*Expr*/ nullptr,
11227  C.getCaptureKind() == LCK_StarThis);
11228  } else {
11229  LSI->addVLATypeCapture(C.getLocation(), I->getType());
11230  }
11231  ++I;
11232  }
11233 }
11234 
11236  SkipBodyInfo *SkipBody) {
11237  // Clear the last template instantiation error context.
11238  LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
11239 
11240  if (!D)
11241  return D;
11242  FunctionDecl *FD = nullptr;
11243 
11244  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
11245  FD = FunTmpl->getTemplatedDecl();
11246  else
11247  FD = cast<FunctionDecl>(D);
11248 
11249  // See if this is a redefinition.
11250  if (!FD->isLateTemplateParsed()) {
11251  CheckForFunctionRedefinition(FD, nullptr, SkipBody);
11252 
11253  // If we're skipping the body, we're done. Don't enter the scope.
11254  if (SkipBody && SkipBody->ShouldSkip)
11255  return D;
11256  }
11257 
11258  // If we are instantiating a generic lambda call operator, push
11259  // a LambdaScopeInfo onto the function stack. But use the information
11260  // that's already been calculated (ActOnLambdaExpr) to prime the current
11261  // LambdaScopeInfo.
11262  // When the template operator is being specialized, the LambdaScopeInfo,
11263  // has to be properly restored so that tryCaptureVariable doesn't try
11264  // and capture any new variables. In addition when calculating potential
11265  // captures during transformation of nested lambdas, it is necessary to
11266  // have the LSI properly restored.
11268  assert(ActiveTemplateInstantiations.size() &&
11269  "There should be an active template instantiation on the stack "
11270  "when instantiating a generic lambda!");
11271  RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
11272  }
11273  else
11274  // Enter a new function scope
11275  PushFunctionScope();
11276 
11277  // Builtin functions cannot be defined.
11278  if (unsigned BuiltinID = FD->getBuiltinID()) {
11279  if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
11281  Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
11282  FD->setInvalidDecl();
11283  }
11284  }
11285 
11286  // The return type of a function definition must be complete
11287  // (C99 6.9.1p3, C++ [dcl.fct]p6).
11288  QualType ResultType = FD->getReturnType();
11289  if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
11290  !FD->isInvalidDecl() &&
11291  RequireCompleteType(FD->getLocation(), ResultType,
11292  diag::err_func_def_incomplete_result))
11293  FD->setInvalidDecl();
11294 
11295  if (FnBodyScope)
11296  PushDeclContext(FnBodyScope, FD);
11297 
11298  // Check the validity of our function parameters
11299  CheckParmsForFunctionDef(FD->parameters(),
11300  /*CheckParameterNames=*/true);
11301 
11302  // Introduce our parameters into the function scope
11303  for (auto Param : FD->parameters()) {
11304  Param->setOwningFunction(FD);
11305 
11306  // If this has an identifier, add it to the scope stack.
11307  if (Param->getIdentifier() && FnBodyScope) {
11308  CheckShadow(FnBodyScope, Param);
11309 
11310  PushOnScopeChains(Param, FnBodyScope);
11311  }
11312  }
11313 
11314  // If we had any tags defined in the function prototype,
11315  // introduce them into the function scope.
11316  if (FnBodyScope) {
11318  I = FD->getDeclsInPrototypeScope().begin(),
11319  E = FD->getDeclsInPrototypeScope().end();
11320  I != E; ++I) {
11321  NamedDecl *D = *I;
11322 
11323  // Some of these decls (like enums) may have been pinned to the
11324  // translation unit for lack of a real context earlier. If so, remove
11325  // from the translation unit and reattach to the current context.
11326  if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) {
11327  // Is the decl actually in the context?
11330  // Either way, reassign the lexical decl context to our FunctionDecl.
11331  D->setLexicalDeclContext(CurContext);
11332  }
11333 
11334  // If the decl has a non-null name, make accessible in the current scope.
11335  if (!D->getName().empty())
11336  PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
11337 
11338  // Similarly, dive into enums and fish their constants out, making them
11339  // accessible in this scope.
11340  if (auto *ED = dyn_cast<EnumDecl>(D)) {
11341  for (auto *EI : ED->enumerators())
11342  PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
11343  }
11344  }
11345  }
11346 
11347  // Ensure that the function's exception specification is instantiated.
11348  if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
11349  ResolveExceptionSpec(D->getLocation(), FPT);
11350 
11351  // dllimport cannot be applied to non-inline function definitions.
11352  if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
11353  !FD->isTemplateInstantiation()) {
11354  assert(!FD->hasAttr<DLLExportAttr>());
11355  Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
11356  FD->setInvalidDecl();
11357  return D;
11358  }
11359  // We want to attach documentation to original Decl (which might be
11360  // a function template).
11361  ActOnDocumentableDecl(D);
11362  if (getCurLexicalContext()->isObjCContainer() &&
11363  getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
11364  getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
11365  Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
11366 
11367  return D;
11368 }
11369 
11370 /// \brief Given the set of return statements within a function body,
11371 /// compute the variables that are subject to the named return value
11372 /// optimization.
11373 ///
11374 /// Each of the variables that is subject to the named return value
11375 /// optimization will be marked as NRVO variables in the AST, and any
11376 /// return statement that has a marked NRVO variable as its NRVO candidate can
11377 /// use the named return value optimization.
11378 ///
11379 /// This function applies a very simplistic algorithm for NRVO: if every return
11380 /// statement in the scope of a variable has the same NRVO candidate, that
11381 /// candidate is an NRVO variable.
11383  ReturnStmt **Returns = Scope->Returns.data();
11384 
11385  for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
11386  if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
11387  if (!NRVOCandidate->isNRVOVariable())
11388  Returns[I]->setNRVOCandidate(nullptr);
11389  }
11390  }
11391 }
11392 
11394  // We can't delay parsing the body of a constexpr function template (yet).
11396  return false;
11397 
11398  // We can't delay parsing the body of a function template with a deduced
11399  // return type (yet).
11401  // If the placeholder introduces a non-deduced trailing return type,
11402  // we can still delay parsing it.
11403  if (D.getNumTypeObjects()) {
11404  const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
11405  if (Outer.Kind == DeclaratorChunk::Function &&
11406  Outer.Fun.hasTrailingReturnType()) {
11407  QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
11408  return Ty.isNull() || !Ty->isUndeducedType();
11409  }
11410  }
11411  return false;
11412  }
11413 
11414  return true;
11415 }
11416 
11418  // We cannot skip the body of a function (or function template) which is
11419  // constexpr, since we may need to evaluate its body in order to parse the
11420  // rest of the file.
11421  // We cannot skip the body of a function with an undeduced return type,
11422  // because any callers of that function need to know the type.
11423  if (const FunctionDecl *FD = D->getAsFunction())
11424  if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
11425  return false;
11426  return Consumer.shouldSkipFunctionBody(D);
11427 }
11428 
11430  if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
11431  FD->setHasSkippedBody();
11432  else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
11433  MD->setHasSkippedBody();
11434  return Decl;
11435 }
11436 
11438  return ActOnFinishFunctionBody(D, BodyArg, false);
11439 }
11440 
11442  bool IsInstantiation) {
11443  FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
11444 
11445  sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
11446  sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
11447 
11448  if (getLangOpts().Coroutines && !getCurFunction()->CoroutineStmts.empty())
11449  CheckCompletedCoroutineBody(FD, Body);
11450 
11451  if (FD) {
11452  FD->setBody(Body);
11453 
11454  if (getLangOpts().CPlusPlus14) {
11455  if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() &&
11456  FD->getReturnType()->isUndeducedType()) {
11457  // If the function has a deduced result type but contains no 'return'
11458  // statements, the result type as written must be exactly 'auto', and
11459  // the deduced result type is 'void'.
11460  if (!FD->getReturnType()->getAs<AutoType>()) {
11461  Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
11462  << FD->getReturnType();
11463  FD->setInvalidDecl();
11464  } else {
11465  // Substitute 'void' for the 'auto' in the type.
11466  TypeLoc ResultType = getReturnTypeLoc(FD);
11468  FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
11469  }
11470  }
11471  } else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) {
11472  // In C++11, we don't use 'auto' deduction rules for lambda call
11473  // operators because we don't support return type deduction.
11474  auto *LSI = getCurLambda();
11475  if (LSI->HasImplicitReturnType) {
11476  deduceClosureReturnType(*LSI);
11477 
11478  // C++11 [expr.prim.lambda]p4:
11479  // [...] if there are no return statements in the compound-statement
11480  // [the deduced type is] the type void
11481  QualType RetType =
11482  LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType;
11483 
11484  // Update the return type to the deduced type.
11485  const FunctionProtoType *Proto =
11486  FD->getType()->getAs<FunctionProtoType>();
11487  FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
11488  Proto->getExtProtoInfo()));
11489  }
11490  }
11491 
11492  // The only way to be included in UndefinedButUsed is if there is an
11493  // ODR use before the definition. Avoid the expensive map lookup if this
11494  // is the first declaration.
11495  if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) {
11496  if (!FD->isExternallyVisible())
11497  UndefinedButUsed.erase(FD);
11498  else if (FD->isInlined() &&
11499  !LangOpts.GNUInline &&
11500  (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
11501  UndefinedButUsed.erase(FD);
11502  }
11503 
11504  // If the function implicitly returns zero (like 'main') or is naked,
11505  // don't complain about missing return statements.
11506  if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
11508 
11509  // MSVC permits the use of pure specifier (=0) on function definition,
11510  // defined at class scope, warn about this non-standard construct.
11511  if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
11512  Diag(FD->getLocation(), diag::ext_pure_function_definition);
11513 
11514  if (!FD->isInvalidDecl()) {
11515  // Don't diagnose unused parameters of defaulted or deleted functions.
11516  if (!FD->isDeleted() && !FD->isDefaulted())
11517  DiagnoseUnusedParameters(FD->parameters());
11518  DiagnoseSizeOfParametersAndReturnValue(FD->parameters(),
11519  FD->getReturnType(), FD);
11520 
11521  // If this is a structor, we need a vtable.
11522  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
11523  MarkVTableUsed(FD->getLocation(), Constructor->getParent());
11524  else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD))
11525  MarkVTableUsed(FD->getLocation(), Destructor->getParent());
11526 
11527  // Try to apply the named return value optimization. We have to check
11528  // if we can do this here because lambdas keep return statements around
11529  // to deduce an implicit return type.
11530  if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
11531  !FD->isDependentContext())
11532  computeNRVO(Body, getCurFunction());
11533  }
11534 
11535  // GNU warning -Wmissing-prototypes:
11536  // Warn if a global function is defined without a previous
11537  // prototype declaration. This warning is issued even if the
11538  // definition itself provides a prototype. The aim is to detect
11539  // global functions that fail to be declared in header files.
11540  const FunctionDecl *PossibleZeroParamPrototype = nullptr;
11541  if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
11542  Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
11543 
11544  if (PossibleZeroParamPrototype) {
11545  // We found a declaration that is not a prototype,
11546  // but that could be a zero-parameter prototype
11547  if (TypeSourceInfo *TI =
11548  PossibleZeroParamPrototype->getTypeSourceInfo()) {
11549  TypeLoc TL = TI->getTypeLoc();
11551  Diag(PossibleZeroParamPrototype->getLocation(),
11552  diag::note_declaration_not_a_prototype)
11553  << PossibleZeroParamPrototype
11554  << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
11555  }
11556  }
11557  }
11558 
11559  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
11560  const CXXMethodDecl *KeyFunction;
11561  if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) &&
11562  MD->isVirtual() &&
11563  (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) &&
11564  MD == KeyFunction->getCanonicalDecl()) {
11565  // Update the key-function state if necessary for this ABI.
11566  if (FD->isInlined() &&
11569 
11570  // If the newly-chosen key function is already defined, then we
11571  // need to mark the vtable as used retroactively.
11572  KeyFunction = Context.getCurrentKeyFunction(MD->getParent());
11573  const FunctionDecl *Definition;
11574  if (KeyFunction && KeyFunction->isDefined(Definition))
11575  MarkVTableUsed(Definition->getLocation(), MD->getParent(), true);
11576  } else {
11577  // We just defined they key function; mark the vtable as used.
11578  MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
11579  }
11580  }
11581  }
11582 
11583  assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
11584  "Function parsing confused");
11585  } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
11586  assert(MD == getCurMethodDecl() && "Method parsing confused");
11587  MD->setBody(Body);
11588  if (!MD->isInvalidDecl()) {
11589  DiagnoseUnusedParameters(MD->parameters());
11590  DiagnoseSizeOfParametersAndReturnValue(MD->parameters(),
11591  MD->getReturnType(), MD);
11592 
11593  if (Body)
11594  computeNRVO(Body, getCurFunction());
11595  }
11596  if (getCurFunction()->ObjCShouldCallSuper) {
11597  Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
11598  << MD->getSelector().getAsString();
11599  getCurFunction()->ObjCShouldCallSuper = false;
11600  }
11601  if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
11602  const ObjCMethodDecl *InitMethod = nullptr;
11603  bool isDesignated =
11604  MD->isDesignatedInitializerForTheInterface(&InitMethod);
11605  assert(isDesignated && InitMethod);
11606  (void)isDesignated;
11607 
11608  auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
11609  auto IFace = MD->getClassInterface();
11610  if (!IFace)
11611  return false;
11612  auto SuperD = IFace->getSuperClass();
11613  if (!SuperD)
11614  return false;
11615  return SuperD->getIdentifier() ==
11616  NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
11617  };
11618  // Don't issue this warning for unavailable inits or direct subclasses
11619  // of NSObject.
11620  if (!MD->isUnavailable() && !superIsNSObject(MD)) {
11621  Diag(MD->getLocation(),
11622  diag::warn_objc_designated_init_missing_super_call);
11623  Diag(InitMethod->getLocation(),
11624  diag::note_objc_designated_init_marked_here);
11625  }
11626  getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
11627  }
11628  if (getCurFunction()->ObjCWarnForNoInitDelegation) {
11629  // Don't issue this warning for unavaialable inits.
11630  if (!MD->isUnavailable())
11631  Diag(MD->getLocation(),
11632  diag::warn_objc_secondary_init_missing_init_call);
11633  getCurFunction()->ObjCWarnForNoInitDelegation = false;
11634  }
11635  } else {
11636  return nullptr;
11637  }
11638 
11639  assert(!getCurFunction()->ObjCShouldCallSuper &&
11640  "This should only be set for ObjC methods, which should have been "
11641  "handled in the block above.");
11642 
11643  // Verify and clean out per-function state.
11644  if (Body && (!FD || !FD->isDefaulted())) {
11645  // C++ constructors that have function-try-blocks can't have return
11646  // statements in the handlers of that block. (C++ [except.handle]p14)
11647  // Verify this.
11648  if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
11649  DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
11650 
11651  // Verify that gotos and switch cases don't jump into scopes illegally.
11652  if (getCurFunction()->NeedsScopeChecking() &&
11653  !PP.isCodeCompletionEnabled())
11654  DiagnoseInvalidJumps(Body);
11655 
11656  if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
11657  if (!Destructor->getParent()->isDependentType())
11658  CheckDestructor(Destructor);
11659 
11660  MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
11661  Destructor->getParent());
11662  }
11663 
11664  // If any errors have occurred, clear out any temporaries that may have
11665  // been leftover. This ensures that these temporaries won't be picked up for
11666  // deletion in some later function.
11667  if (getDiagnostics().hasErrorOccurred() ||
11668  getDiagnostics().getSuppressAllDiagnostics()) {
11669  DiscardCleanupsInEvaluationContext();
11670  }
11671  if (!getDiagnostics().hasUncompilableErrorOccurred() &&
11672  !isa<FunctionTemplateDecl>(dcl)) {
11673  // Since the body is valid, issue any analysis-based warnings that are
11674  // enabled.
11675  ActivePolicy = &WP;
11676  }
11677 
11678  if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
11679  (!CheckConstexprFunctionDecl(FD) ||
11680  !CheckConstexprFunctionBody(FD, Body)))
11681  FD->setInvalidDecl();
11682 
11683  if (FD && FD->hasAttr<NakedAttr>()) {
11684  for (const Stmt *S : Body->children()) {
11685  if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
11686  Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function);
11687  Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
11688  FD->setInvalidDecl();
11689  break;
11690  }
11691  }
11692  }
11693 
11694  assert(ExprCleanupObjects.size() ==
11695  ExprEvalContexts.back().NumCleanupObjects &&
11696  "Leftover temporaries in function");
11697  assert(!Cleanup.exprNeedsCleanups() && "Unaccounted cleanups in function");
11698  assert(MaybeODRUseExprs.empty() &&
11699  "Leftover expressions for odr-use checking");
11700  }
11701 
11702  if (!IsInstantiation)
11703  PopDeclContext();
11704 
11705  PopFunctionScopeInfo(ActivePolicy, dcl);
11706  // If any errors have occurred, clear out any temporaries that may have
11707  // been leftover. This ensures that these temporaries won't be picked up for
11708  // deletion in some later function.
11709  if (getDiagnostics().hasErrorOccurred()) {
11710  DiscardCleanupsInEvaluationContext();
11711  }
11712 
11713  return dcl;
11714 }
11715 
11716 /// When we finish delayed parsing of an attribute, we must attach it to the
11717 /// relevant Decl.
11719  ParsedAttributes &Attrs) {
11720  // Always attach attributes to the underlying decl.
11721  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
11722  D = TD->getTemplatedDecl();
11723  ProcessDeclAttributeList(S, D, Attrs.getList());
11724 
11725  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
11726  if (Method->isStatic())
11727  checkThisInStaticMemberFunctionAttributes(Method);
11728 }
11729 
11730 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
11731 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
11733  IdentifierInfo &II, Scope *S) {
11734  // Before we produce a declaration for an implicitly defined
11735  // function, see whether there was a locally-scoped declaration of
11736  // this name as a function or variable. If so, use that
11737  // (non-visible) declaration, and complain about it.
11738  if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
11739  Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev;
11740  Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
11741  return ExternCPrev;
11742  }
11743 
11744  // Extension in C99. Legal in C90, but warn about it.
11745  unsigned diag_id;
11746  if (II.getName().startswith("__builtin_"))
11747  diag_id = diag::warn_builtin_unknown;
11748  else if (getLangOpts().C99)
11749  diag_id = diag::ext_implicit_function_decl;
11750  else
11751  diag_id = diag::warn_implicit_function_decl;
11752  Diag(Loc, diag_id) << &II;
11753 
11754  // Because typo correction is expensive, only do it if the implicit
11755  // function declaration is going to be treated as an error.
11756  if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
11757  TypoCorrection Corrected;
11758  if (S &&
11759  (Corrected = CorrectTypo(
11760  DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr,
11761  llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError)))
11762  diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
11763  /*ErrorRecovery*/false);
11764  }
11765 
11766  // Set a Declarator for the implicit definition: int foo();
11767  const char *Dummy;
11768  AttributeFactory attrFactory;
11769  DeclSpec DS(attrFactory);
11770  unsigned DiagID;
11771  bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
11773  (void)Error; // Silence warning.
11774  assert(!Error && "Error setting up implicit decl!");
11775  SourceLocation NoLoc;
11777  D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
11778  /*IsAmbiguous=*/false,
11779  /*LParenLoc=*/NoLoc,
11780  /*Params=*/nullptr,
11781  /*NumParams=*/0,
11782  /*EllipsisLoc=*/NoLoc,
11783  /*RParenLoc=*/NoLoc,
11784  /*TypeQuals=*/0,
11785  /*RefQualifierIsLvalueRef=*/true,
11786  /*RefQualifierLoc=*/NoLoc,
11787  /*ConstQualifierLoc=*/NoLoc,
11788  /*VolatileQualifierLoc=*/NoLoc,
11789  /*RestrictQualifierLoc=*/NoLoc,
11790  /*MutableLoc=*/NoLoc,
11791  EST_None,
11792  /*ESpecRange=*/SourceRange(),
11793  /*Exceptions=*/nullptr,
11794  /*ExceptionRanges=*/nullptr,
11795  /*NumExceptions=*/0,
11796  /*NoexceptExpr=*/nullptr,
11797  /*ExceptionSpecTokens=*/nullptr,
11798  Loc, Loc, D),
11799  DS.getAttributes(),
11800  SourceLocation());
11801  D.SetIdentifier(&II, Loc);
11802 
11803  // Insert this function into translation-unit scope.
11804 
11805  DeclContext *PrevDC = CurContext;
11806  CurContext = Context.getTranslationUnitDecl();
11807 
11808  FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
11809  FD->setImplicit();
11810 
11811  CurContext = PrevDC;
11812 
11813  AddKnownFunctionAttributes(FD);
11814 
11815  return FD;
11816 }
11817 
11818 /// \brief Adds any function attributes that we know a priori based on
11819 /// the declaration of this function.
11820 ///
11821 /// These attributes can apply both to implicitly-declared builtins
11822 /// (like __builtin___printf_chk) or to library-declared functions
11823 /// like NSLog or printf.
11824 ///
11825 /// We need to check for duplicate attributes both here and where user-written
11826 /// attributes are applied to declarations.
11828  if (FD->isInvalidDecl())
11829  return;
11830 
11831  // If this is a built-in function, map its builtin attributes to
11832  // actual attributes.
11833  if (unsigned BuiltinID = FD->getBuiltinID()) {
11834  // Handle printf-formatting attributes.
11835  unsigned FormatIdx;
11836  bool HasVAListArg;
11837  if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
11838  if (!FD->hasAttr<FormatAttr>()) {
11839  const char *fmt = "printf";
11840  unsigned int NumParams = FD->getNumParams();
11841  if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
11842  FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
11843  fmt = "NSString";
11844  FD->addAttr(FormatAttr::CreateImplicit(Context,
11845  &Context.Idents.get(fmt),
11846  FormatIdx+1,
11847  HasVAListArg ? 0 : FormatIdx+2,
11848  FD->getLocation()));
11849  }
11850  }
11851  if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
11852  HasVAListArg)) {
11853  if (!FD->hasAttr<FormatAttr>())
11854  FD->addAttr(FormatAttr::CreateImplicit(Context,
11855  &Context.Idents.get("scanf"),
11856  FormatIdx+1,
11857  HasVAListArg ? 0 : FormatIdx+2,
11858  FD->getLocation()));
11859  }
11860 
11861  // Mark const if we don't care about errno and that is the only
11862  // thing preventing the function from being const. This allows
11863  // IRgen to use LLVM intrinsics for such functions.
11864  if (!getLangOpts().MathErrno &&
11866  if (!FD->hasAttr<ConstAttr>())
11867  FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
11868  }
11869 
11870  if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
11871  !FD->hasAttr<ReturnsTwiceAttr>())
11872  FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
11873  FD->getLocation()));
11874  if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
11875  FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
11876  if (Context.BuiltinInfo.isPure(BuiltinID) && !FD->hasAttr<PureAttr>())
11877  FD->addAttr(PureAttr::CreateImplicit(Context, FD->getLocation()));
11878  if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
11879  FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
11880  if (getLangOpts().CUDA && Context.BuiltinInfo.isTSBuiltin(BuiltinID) &&
11881  !FD->hasAttr<CUDADeviceAttr>() && !FD->hasAttr<CUDAHostAttr>()) {
11882  // Add the appropriate attribute, depending on the CUDA compilation mode
11883  // and which target the builtin belongs to. For example, during host
11884  // compilation, aux builtins are __device__, while the rest are __host__.
11885  if (getLangOpts().CUDAIsDevice !=
11886  Context.BuiltinInfo.isAuxBuiltinID(BuiltinID))
11887  FD->addAttr(CUDADeviceAttr::CreateImplicit(Context, FD->getLocation()));
11888  else
11889  FD->addAttr(CUDAHostAttr::CreateImplicit(Context, FD->getLocation()));
11890  }
11891  }
11892 
11893  // If C++ exceptions are enabled but we are told extern "C" functions cannot
11894  // throw, add an implicit nothrow attribute to any extern "C" function we come
11895  // across.
11896  if (getLangOpts().CXXExceptions && getLangOpts().ExternCNoUnwind &&
11897  FD->isExternC() && !FD->hasAttr<NoThrowAttr>()) {
11898  const auto *FPT = FD->getType()->getAs<FunctionProtoType>();
11899  if (!FPT || FPT->getExceptionSpecType() == EST_None)
11900  FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
11901  }
11902 
11903  IdentifierInfo *Name = FD->getIdentifier();
11904  if (!Name)
11905  return;
11906  if ((!getLangOpts().CPlusPlus &&
11907  FD->getDeclContext()->isTranslationUnit()) ||
11908  (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
11909  cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
11911  // Okay: this could be a libc/libm/Objective-C function we know
11912  // about.
11913  } else
11914  return;
11915 
11916  if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
11917  // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
11918  // target-specific builtins, perhaps?
11919  if (!FD->hasAttr<FormatAttr>())
11920  FD->addAttr(FormatAttr::CreateImplicit(Context,
11921  &Context.Idents.get("printf"), 2,
11922  Name->isStr("vasprintf") ? 0 : 3,
11923  FD->getLocation()));
11924  }
11925 
11926  if (Name->isStr("__CFStringMakeConstantString")) {
11927  // We already have a __builtin___CFStringMakeConstantString,
11928  // but builds that use -fno-constant-cfstrings don't go through that.
11929  if (!FD->hasAttr<FormatArgAttr>())
11930  FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1,
11931  FD->getLocation()));
11932  }
11933 }
11934 
11936  TypeSourceInfo *TInfo) {
11937  assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
11938  assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
11939 
11940  if (!TInfo) {
11941  assert(D.isInvalidType() && "no declarator info for valid type");
11942  TInfo = Context.getTrivialTypeSourceInfo(T);
11943  }
11944 
11945  // Scope manipulation handled by caller.
11946  TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
11947  D.getLocStart(),
11948  D.getIdentifierLoc(),
11949  D.getIdentifier(),
11950  TInfo);
11951 
11952  // Bail out immediately if we have an invalid declaration.
11953  if (D.isInvalidType()) {
11954  NewTD->setInvalidDecl();
11955  return NewTD;
11956  }
11957 
11959  if (CurContext->isFunctionOrMethod())
11960  Diag(NewTD->getLocation(), diag::err_module_private_local)
11961  << 2 << NewTD->getDeclName()
11964  else
11965  NewTD->setModulePrivate();
11966  }
11967 
11968  // C++ [dcl.typedef]p8:
11969  // If the typedef declaration defines an unnamed class (or
11970  // enum), the first typedef-name declared by the declaration
11971  // to be that class type (or enum type) is used to denote the
11972  // class type (or enum type) for linkage purposes only.
11973  // We need to check whether the type was declared in the declaration.
11974  switch (D.getDeclSpec().getTypeSpecType()) {
11975  case TST_enum:
11976  case TST_struct:
11977  case TST_interface:
11978  case TST_union:
11979  case TST_class: {
11980  TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
11981  setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD);
11982  break;
11983  }
11984 
11985  default:
11986  break;
11987  }
11988 
11989  return NewTD;
11990 }
11991 
11992 /// \brief Check that this is a valid underlying type for an enum declaration.
11994  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
11995  QualType T = TI->getType();
11996 
11997  if (T->isDependentType())
11998  return false;
11999 
12000  if (const BuiltinType *BT = T->getAs<BuiltinType>())
12001  if (BT->isInteger())
12002  return false;
12003 
12004  Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
12005  return true;
12006 }
12007 
12008 /// Check whether this is a valid redeclaration of a previous enumeration.
12009 /// \return true if the redeclaration was invalid.
12011  SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy,
12012  bool EnumUnderlyingIsImplicit, const EnumDecl *Prev) {
12013  bool IsFixed = !EnumUnderlyingTy.isNull();
12014 
12015  if (IsScoped != Prev->isScoped()) {
12016  Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
12017  << Prev->isScoped();
12018  Diag(Prev->getLocation(), diag::note_previous_declaration);
12019  return true;
12020  }
12021 
12022  if (IsFixed && Prev->isFixed()) {
12023  if (!EnumUnderlyingTy->isDependentType() &&
12024  !Prev->getIntegerType()->isDependentType() &&
12025  !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
12026  Prev->getIntegerType())) {
12027  // TODO: Highlight the underlying type of the redeclaration.
12028  Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
12029  << EnumUnderlyingTy << Prev->getIntegerType();
12030  Diag(Prev->getLocation(), diag::note_previous_declaration)
12031  << Prev->getIntegerTypeRange();
12032  return true;
12033  }
12034  } else if (IsFixed && !Prev->isFixed() && EnumUnderlyingIsImplicit) {
12035  ;
12036  } else if (!IsFixed && Prev->isFixed() && !Prev->getIntegerTypeSourceInfo()) {
12037  ;
12038  } else if (IsFixed != Prev->isFixed()) {
12039  Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
12040  << Prev->isFixed();
12041  Diag(Prev->getLocation(), diag::note_previous_declaration);
12042  return true;
12043  }
12044 
12045  return false;
12046 }
12047 
12048 /// \brief Get diagnostic %select index for tag kind for
12049 /// redeclaration diagnostic message.
12050 /// WARNING: Indexes apply to particular diagnostics only!
12051 ///
12052 /// \returns diagnostic %select index.
12054  switch (Tag) {
12055  case TTK_Struct: return 0;
12056  case TTK_Interface: return 1;
12057  case TTK_Class: return 2;
12058  default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
12059  }
12060 }
12061 
12062 /// \brief Determine if tag kind is a class-key compatible with
12063 /// class for redeclaration (class, struct, or __interface).
12064 ///
12065 /// \returns true iff the tag kind is compatible.
12067 {
12068  return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
12069 }
12070 
12071 /// \brief Determine whether a tag with a given kind is acceptable
12072 /// as a redeclaration of the given tag declaration.
12073 ///
12074 /// \returns true if the new tag kind is acceptable, false otherwise.
12076  TagTypeKind NewTag, bool isDefinition,
12077  SourceLocation NewTagLoc,
12078  const IdentifierInfo *Name) {
12079  // C++ [dcl.type.elab]p3:
12080  // The class-key or enum keyword present in the
12081  // elaborated-type-specifier shall agree in kind with the
12082  // declaration to which the name in the elaborated-type-specifier
12083  // refers. This rule also applies to the form of
12084  // elaborated-type-specifier that declares a class-name or
12085  // friend class since it can be construed as referring to the
12086  // definition of the class. Thus, in any
12087  // elaborated-type-specifier, the enum keyword shall be used to
12088  // refer to an enumeration (7.2), the union class-key shall be
12089  // used to refer to a union (clause 9), and either the class or
12090  // struct class-key shall be used to refer to a class (clause 9)
12091  // declared using the class or struct class-key.
12092  TagTypeKind OldTag = Previous->getTagKind();
12093  if (!isDefinition || !isClassCompatTagKind(NewTag))
12094  if (OldTag == NewTag)
12095  return true;
12096 
12097  if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
12098  // Warn about the struct/class tag mismatch.
12099  bool isTemplate = false;
12100  if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
12101  isTemplate = Record->getDescribedClassTemplate();
12102 
12103  if (!ActiveTemplateInstantiations.empty()) {
12104  // In a template instantiation, do not offer fix-its for tag mismatches
12105  // since they usually mess up the template instead of fixing the problem.
12106  Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
12107  << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
12108  << getRedeclDiagFromTagKind(OldTag);
12109  return true;
12110  }
12111 
12112  if (isDefinition) {
12113  // On definitions, check previous tags and issue a fix-it for each
12114  // one that doesn't match the current tag.
12115  if (Previous->getDefinition()) {
12116  // Don't suggest fix-its for redefinitions.
12117  return true;
12118  }
12119 
12120  bool previousMismatch = false;
12121  for (auto I : Previous->redecls()) {
12122  if (I->getTagKind() != NewTag) {
12123  if (!previousMismatch) {
12124  previousMismatch = true;
12125  Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
12126  << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
12127  << getRedeclDiagFromTagKind(I->getTagKind());
12128  }
12129  Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
12130  << getRedeclDiagFromTagKind(NewTag)
12131  << FixItHint::CreateReplacement(I->getInnerLocStart(),
12133  }
12134  }
12135  return true;
12136  }
12137 
12138  // Check for a previous definition. If current tag and definition
12139  // are same type, do nothing. If no definition, but disagree with
12140  // with previous tag type, give a warning, but no fix-it.
12141  const TagDecl *Redecl = Previous->getDefinition() ?
12142  Previous->getDefinition() : Previous;
12143  if (Redecl->getTagKind() == NewTag) {
12144  return true;
12145  }
12146 
12147  Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
12148  << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
12149  << getRedeclDiagFromTagKind(OldTag);
12150  Diag(Redecl->getLocation(), diag::note_previous_use);
12151 
12152  // If there is a previous definition, suggest a fix-it.
12153  if (Previous->getDefinition()) {
12154  Diag(NewTagLoc, diag::note_struct_class_suggestion)
12155  << getRedeclDiagFromTagKind(Redecl->getTagKind())
12158  }
12159 
12160  return true;
12161  }
12162  return false;
12163 }
12164 
12165 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
12166 /// from an outer enclosing namespace or file scope inside a friend declaration.
12167 /// This should provide the commented out code in the following snippet:
12168 /// namespace N {
12169 /// struct X;
12170 /// namespace M {
12171 /// struct Y { friend struct /*N::*/ X; };
12172 /// }
12173 /// }
12175  SourceLocation NameLoc) {
12176  // While the decl is in a namespace, do repeated lookup of that name and see
12177  // if we get the same namespace back. If we do not, continue until
12178  // translation unit scope, at which point we have a fully qualified NNS.
12180  DeclContext *DC = ND->getDeclContext()->getRedeclContext();
12181  for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
12182  // This tag should be declared in a namespace, which can only be enclosed by
12183  // other namespaces. Bail if there's an anonymous namespace in the chain.
12184  NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
12185  if (!Namespace || Namespace->isAnonymousNamespace())
12186  return FixItHint();
12187  IdentifierInfo *II = Namespace->getIdentifier();
12188  Namespaces.push_back(II);
12189  NamedDecl *Lookup = SemaRef.LookupSingleName(
12190  S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
12191  if (Lookup == Namespace)
12192  break;
12193  }
12194 
12195  // Once we have all the namespaces, reverse them to go outermost first, and
12196  // build an NNS.
12197  SmallString<64> Insertion;
12198  llvm::raw_svector_ostream OS(Insertion);
12199  if (DC->isTranslationUnit())
12200  OS << "::";
12201  std::reverse(Namespaces.begin(), Namespaces.end());
12202  for (auto *II : Namespaces)
12203  OS << II->getName() << "::";
12204  return FixItHint::CreateInsertion(NameLoc, Insertion);
12205 }
12206 
12207 /// \brief Determine whether a tag originally declared in context \p OldDC can
12208 /// be redeclared with an unqualfied name in \p NewDC (assuming name lookup
12209 /// found a declaration in \p OldDC as a previous decl, perhaps through a
12210 /// using-declaration).
12212  DeclContext *NewDC) {
12213  OldDC = OldDC->getRedeclContext();
12214  NewDC = NewDC->getRedeclContext();
12215 
12216  if (OldDC->Equals(NewDC))
12217  return true;
12218 
12219  // In MSVC mode, we allow a redeclaration if the contexts are related (either
12220  // encloses the other).
12221  if (S.getLangOpts().MSVCCompat &&
12222  (OldDC->Encloses(NewDC) || NewDC->Encloses(OldDC)))
12223  return true;
12224 
12225  return false;
12226 }
12227 
12228 /// Find the DeclContext in which a tag is implicitly declared if we see an
12229 /// elaborated type specifier in the specified context, and lookup finds
12230 /// nothing.
12232  while (!DC->isFileContext() && !DC->isFunctionOrMethod())
12233  DC = DC->getParent();
12234  return DC;
12235 }
12236 
12237 /// Find the Scope in which a tag is implicitly declared if we see an
12238 /// elaborated type specifier in the specified context, and lookup finds
12239 /// nothing.
12240 static Scope *getTagInjectionScope(Scope *S, const LangOptions &LangOpts) {
12241  while (S->isClassScope() ||
12242  (LangOpts.CPlusPlus &&
12243  S->isFunctionPrototypeScope()) ||
12244  ((S->getFlags() & Scope::DeclScope) == 0) ||
12245  (S->getEntity() && S->getEntity()->isTransparentContext()))
12246  S = S->getParent();
12247  return S;
12248 }
12249 
12250 /// \brief This is invoked when we see 'struct foo' or 'struct {'. In the
12251 /// former case, Name will be non-null. In the later case, Name will be null.
12252 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
12253 /// reference/declaration/definition of a tag.
12254 ///
12255 /// \param IsTypeSpecifier \c true if this is a type-specifier (or
12256 /// trailing-type-specifier) other than one in an alias-declaration.
12257 ///
12258 /// \param SkipBody If non-null, will be set to indicate if the caller should
12259 /// skip the definition of this tag and treat it as if it were a declaration.
12260 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
12261  SourceLocation KWLoc, CXXScopeSpec &SS,
12262  IdentifierInfo *Name, SourceLocation NameLoc,
12264  SourceLocation ModulePrivateLoc,
12265  MultiTemplateParamsArg TemplateParameterLists,
12266  bool &OwnedDecl, bool &IsDependent,
12267  SourceLocation ScopedEnumKWLoc,
12268  bool ScopedEnumUsesClassTag,
12269  TypeResult UnderlyingType,
12270  bool IsTypeSpecifier, SkipBodyInfo *SkipBody) {
12271  // If this is not a definition, it must have a name.
12272  IdentifierInfo *OrigName = Name;
12273  assert((Name != nullptr || TUK == TUK_Definition) &&
12274  "Nameless record must be a definition!");
12275  assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
12276 
12277  OwnedDecl = false;
12279  bool ScopedEnum = ScopedEnumKWLoc.isValid();
12280 
12281  // FIXME: Check explicit specializations more carefully.
12282  bool isExplicitSpecialization = false;
12283  bool Invalid = false;
12284 
12285  // We only need to do this matching if we have template parameters
12286  // or a scope specifier, which also conveniently avoids this work
12287  // for non-C++ cases.
12288  if (TemplateParameterLists.size() > 0 ||
12289  (SS.isNotEmpty() && TUK != TUK_Reference)) {
12290  if (TemplateParameterList *TemplateParams =
12291  MatchTemplateParametersToScopeSpecifier(
12292  KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
12293  TUK == TUK_Friend, isExplicitSpecialization, Invalid)) {
12294  if (Kind == TTK_Enum) {
12295  Diag(KWLoc, diag::err_enum_template);
12296  return nullptr;
12297  }
12298 
12299  if (TemplateParams->size() > 0) {
12300  // This is a declaration or definition of a class template (which may
12301  // be a member of another template).
12302 
12303  if (Invalid)
12304  return nullptr;
12305 
12306  OwnedDecl = false;
12307  DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
12308  SS, Name, NameLoc, Attr,
12309  TemplateParams, AS,
12310  ModulePrivateLoc,
12311  /*FriendLoc*/SourceLocation(),
12312  TemplateParameterLists.size()-1,
12313  TemplateParameterLists.data(),
12314  SkipBody);
12315  return Result.get();
12316  } else {
12317  // The "template<>" header is extraneous.
12318  Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
12320  isExplicitSpecialization = true;
12321  }
12322  }
12323  }
12324 
12325  // Figure out the underlying type if this a enum declaration. We need to do
12326  // this early, because it's needed to detect if this is an incompatible
12327  // redeclaration.
12328  llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
12329  bool EnumUnderlyingIsImplicit = false;
12330 
12331  if (Kind == TTK_Enum) {
12332  if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
12333  // No underlying type explicitly specified, or we failed to parse the
12334  // type, default to int.
12335  EnumUnderlying = Context.IntTy.getTypePtr();
12336  else if (UnderlyingType.get()) {
12337  // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
12338  // integral type; any cv-qualification is ignored.
12339  TypeSourceInfo *TI = nullptr;
12340  GetTypeFromParser(UnderlyingType.get(), &TI);
12341  EnumUnderlying = TI;
12342 
12343  if (CheckEnumUnderlyingType(TI))
12344  // Recover by falling back to int.
12345  EnumUnderlying = Context.IntTy.getTypePtr();
12346 
12347  if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
12348  UPPC_FixedUnderlyingType))
12349  EnumUnderlying = Context.IntTy.getTypePtr();
12350 
12351  } else if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
12352  if (getLangOpts().MSVCCompat || TUK == TUK_Definition) {
12353  // Microsoft enums are always of int type.
12354  EnumUnderlying = Context.IntTy.getTypePtr();
12355  EnumUnderlyingIsImplicit = true;
12356  }
12357  }
12358  }
12359 
12360  DeclContext *SearchDC = CurContext;
12361  DeclContext *DC = CurContext;
12362  bool isStdBadAlloc = false;
12363 
12364  RedeclarationKind Redecl = ForRedeclaration;
12365  if (TUK == TUK_Friend || TUK == TUK_Reference)
12366  Redecl = NotForRedeclaration;
12367 
12368  LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
12369  if (Name && SS.isNotEmpty()) {
12370  // We have a nested-name tag ('struct foo::bar').
12371 
12372  // Check for invalid 'foo::'.
12373  if (SS.isInvalid()) {
12374  Name = nullptr;
12375  goto CreateNewDecl;
12376  }
12377 
12378  // If this is a friend or a reference to a class in a dependent
12379  // context, don't try to make a decl for it.
12380  if (TUK == TUK_Friend || TUK == TUK_Reference) {
12381  DC = computeDeclContext(SS, false);
12382  if (!DC) {
12383  IsDependent = true;
12384  return nullptr;
12385  }
12386  } else {
12387  DC = computeDeclContext(SS, true);
12388  if (!DC) {
12389  Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
12390  << SS.getRange();
12391  return nullptr;
12392  }
12393  }
12394 
12395  if (RequireCompleteDeclContext(SS, DC))
12396  return nullptr;
12397 
12398  SearchDC = DC;
12399  // Look-up name inside 'foo::'.
12400  LookupQualifiedName(Previous, DC);
12401 
12402  if (Previous.isAmbiguous())
12403  return nullptr;
12404 
12405  if (Previous.empty()) {
12406  // Name lookup did not find anything. However, if the
12407  // nested-name-specifier refers to the current instantiation,
12408  // and that current instantiation has any dependent base
12409  // classes, we might find something at instantiation time: treat
12410  // this as a dependent elaborated-type-specifier.
12411  // But this only makes any sense for reference-like lookups.
12412  if (Previous.wasNotFoundInCurrentInstantiation() &&
12413  (TUK == TUK_Reference || TUK == TUK_Friend)) {
12414  IsDependent = true;
12415  return nullptr;
12416  }
12417 
12418  // A tag 'foo::bar' must already exist.
12419  Diag(NameLoc, diag::err_not_tag_in_scope)
12420  << Kind << Name << DC << SS.getRange();
12421  Name = nullptr;
12422  Invalid = true;
12423  goto CreateNewDecl;
12424  }
12425  } else if (Name) {
12426  // C++14 [class.mem]p14:
12427  // If T is the name of a class, then each of the following shall have a
12428  // name different from T:
12429  // -- every member of class T that is itself a type
12430  if (TUK != TUK_Reference && TUK != TUK_Friend &&
12431  DiagnoseClassNameShadow(SearchDC, DeclarationNameInfo(Name, NameLoc)))
12432  return nullptr;
12433 
12434  // If this is a named struct, check to see if there was a previous forward
12435  // declaration or definition.
12436  // FIXME: We're looking into outer scopes here, even when we
12437  // shouldn't be. Doing so can result in ambiguities that we
12438  // shouldn't be diagnosing.
12439  LookupName(Previous, S);
12440 
12441  // When declaring or defining a tag, ignore ambiguities introduced
12442  // by types using'ed into this scope.
12443  if (Previous.isAmbiguous() &&
12444  (TUK == TUK_Definition || TUK == TUK_Declaration)) {
12445  LookupResult::Filter F = Previous.makeFilter();
12446  while (F.hasNext()) {
12447  NamedDecl *ND = F.next();
12448  if (!ND->getDeclContext()->getRedeclContext()->Equals(
12449  SearchDC->getRedeclContext()))
12450  F.erase();
12451  }
12452  F.done();
12453  }
12454 
12455  // C++11 [namespace.memdef]p3:
12456  // If the name in a friend declaration is neither qualified nor
12457  // a template-id and the declaration is a function or an
12458  // elaborated-type-specifier, the lookup to determine whether
12459  // the entity has been previously declared shall not consider
12460  // any scopes outside the innermost enclosing namespace.
12461  //
12462  // MSVC doesn't implement the above rule for types, so a friend tag
12463  // declaration may be a redeclaration of a type declared in an enclosing
12464  // scope. They do implement this rule for friend functions.
12465  //
12466  // Does it matter that this should be by scope instead of by
12467  // semantic context?
12468  if (!Previous.empty() && TUK == TUK_Friend) {
12469  DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
12470  LookupResult::Filter F = Previous.makeFilter();
12471  bool FriendSawTagOutsideEnclosingNamespace = false;
12472  while (F.hasNext()) {
12473  NamedDecl *ND = F.next();
12474  DeclContext *DC = ND->getDeclContext()->getRedeclContext();
12475  if (DC->isFileContext() &&
12476  !EnclosingNS->Encloses(ND->getDeclContext())) {
12477  if (getLangOpts().MSVCCompat)
12478  FriendSawTagOutsideEnclosingNamespace = true;
12479  else
12480  F.erase();
12481  }
12482  }
12483  F.done();
12484 
12485  // Diagnose this MSVC extension in the easy case where lookup would have
12486  // unambiguously found something outside the enclosing namespace.
12487  if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
12488  NamedDecl *ND = Previous.getFoundDecl();
12489  Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
12490  << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
12491  }
12492  }
12493 
12494  // Note: there used to be some attempt at recovery here.
12495  if (Previous.isAmbiguous())
12496  return nullptr;
12497 
12498  if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
12499  // FIXME: This makes sure that we ignore the contexts associated
12500  // with C structs, unions, and enums when looking for a matching
12501  // tag declaration or definition. See the similar lookup tweak
12502  // in Sema::LookupName; is there a better way to deal with this?
12503  while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
12504  SearchDC = SearchDC->getParent();
12505  }
12506  }
12507 
12508  if (Previous.isSingleResult() &&
12509  Previous.getFoundDecl()->isTemplateParameter()) {
12510  // Maybe we will complain about the shadowed template parameter.
12511  DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
12512  // Just pretend that we didn't see the previous declaration.
12513  Previous.clear();
12514  }
12515 
12516  if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
12517  DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
12518  // This is a declaration of or a reference to "std::bad_alloc".
12519  isStdBadAlloc = true;
12520 
12521  if (Previous.empty() && StdBadAlloc) {
12522  // std::bad_alloc has been implicitly declared (but made invisible to
12523  // name lookup). Fill in this implicit declaration as the previous
12524  // declaration, so that the declarations get chained appropriately.
12525  Previous.addDecl(getStdBadAlloc());
12526  }
12527  }
12528 
12529  // If we didn't find a previous declaration, and this is a reference
12530  // (or friend reference), move to the correct scope. In C++, we
12531  // also need to do a redeclaration lookup there, just in case
12532  // there's a shadow friend decl.
12533  if (Name && Previous.empty() &&
12534  (TUK == TUK_Reference || TUK == TUK_Friend)) {
12535  if (Invalid) goto CreateNewDecl;
12536  assert(SS.isEmpty());
12537 
12538  if (TUK == TUK_Reference) {
12539  // C++ [basic.scope.pdecl]p5:
12540  // -- for an elaborated-type-specifier of the form
12541  //
12542  // class-key identifier
12543  //
12544  // if the elaborated-type-specifier is used in the
12545  // decl-specifier-seq or parameter-declaration-clause of a
12546  // function defined in namespace scope, the identifier is
12547  // declared as a class-name in the namespace that contains
12548  // the declaration; otherwise, except as a friend
12549  // declaration, the identifier is declared in the smallest
12550  // non-class, non-function-prototype scope that contains the
12551  // declaration.
12552  //
12553  // C99 6.7.2.3p8 has a similar (but not identical!) provision for
12554  // C structs and unions.
12555  //
12556  // It is an error in C++ to declare (rather than define) an enum
12557  // type, including via an elaborated type specifier. We'll
12558  // diagnose that later; for now, declare the enum in the same
12559  // scope as we would have picked for any other tag type.
12560  //
12561  // GNU C also supports this behavior as part of its incomplete
12562  // enum types extension, while GNU C++ does not.
12563  //
12564  // Find the context where we'll be declaring the tag.
12565  // FIXME: We would like to maintain the current DeclContext as the
12566  // lexical context,
12567  SearchDC = getTagInjectionContext(SearchDC);
12568 
12569  // Find the scope where we'll be declaring the tag.
12570  S = getTagInjectionScope(S, getLangOpts());
12571  } else {
12572  assert(TUK == TUK_Friend);
12573  // C++ [namespace.memdef]p3:
12574  // If a friend declaration in a non-local class first declares a
12575  // class or function, the friend class or function is a member of
12576  // the innermost enclosing namespace.
12577  SearchDC = SearchDC->getEnclosingNamespaceContext();
12578  }
12579 
12580  // In C++, we need to do a redeclaration lookup to properly
12581  // diagnose some problems.
12582  // FIXME: redeclaration lookup is also used (with and without C++) to find a
12583  // hidden declaration so that we don't get ambiguity errors when using a
12584  // type declared by an elaborated-type-specifier. In C that is not correct
12585  // and we should instead merge compatible types found by lookup.
12586  if (getLangOpts().CPlusPlus) {
12587  Previous.setRedeclarationKind(ForRedeclaration);
12588  LookupQualifiedName(Previous, SearchDC);
12589  } else {
12590  Previous.setRedeclarationKind(ForRedeclaration);
12591  LookupName(Previous, S);
12592  }
12593  }
12594 
12595  // If we have a known previous declaration to use, then use it.
12596  if (Previous.empty() && SkipBody && SkipBody->Previous)
12597  Previous.addDecl(SkipBody->Previous);
12598 
12599  if (!Previous.empty()) {
12600  NamedDecl *PrevDecl = Previous.getFoundDecl();
12601  NamedDecl *DirectPrevDecl = Previous.getRepresentativeDecl();
12602 
12603  // It's okay to have a tag decl in the same scope as a typedef
12604  // which hides a tag decl in the same scope. Finding this
12605  // insanity with a redeclaration lookup can only actually happen
12606  // in C++.
12607  //
12608  // This is also okay for elaborated-type-specifiers, which is
12609  // technically forbidden by the current standard but which is
12610  // okay according to the likely resolution of an open issue;
12611  // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
12612  if (getLangOpts().CPlusPlus) {
12613  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
12614  if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
12615  TagDecl *Tag = TT->getDecl();
12616  if (Tag->getDeclName() == Name &&
12617  Tag->getDeclContext()->getRedeclContext()
12618  ->Equals(TD->getDeclContext()->getRedeclContext())) {
12619  PrevDecl = Tag;
12620  Previous.clear();
12621  Previous.addDecl(Tag);
12622  Previous.resolveKind();
12623  }
12624  }
12625  }
12626  }
12627 
12628  // If this is a redeclaration of a using shadow declaration, it must
12629  // declare a tag in the same context. In MSVC mode, we allow a
12630  // redefinition if either context is within the other.
12631  if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
12632  auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
12633  if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend &&
12634  isDeclInScope(Shadow, SearchDC, S, isExplicitSpecialization) &&
12635  !(OldTag && isAcceptableTagRedeclContext(
12636  *this, OldTag->getDeclContext(), SearchDC))) {
12637  Diag(KWLoc, diag::err_using_decl_conflict_reverse);
12638  Diag(Shadow->getTargetDecl()->getLocation(),
12639  diag::note_using_decl_target);
12640  Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl)
12641  << 0;
12642  // Recover by ignoring the old declaration.
12643  Previous.clear();
12644  goto CreateNewDecl;
12645  }
12646  }
12647 
12648  if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
12649  // If this is a use of a previous tag, or if the tag is already declared
12650  // in the same scope (so that the definition/declaration completes or
12651  // rementions the tag), reuse the decl.
12652  if (TUK == TUK_Reference || TUK == TUK_Friend ||
12653  isDeclInScope(DirectPrevDecl, SearchDC, S,
12654  SS.isNotEmpty() || isExplicitSpecialization)) {
12655  // Make sure that this wasn't declared as an enum and now used as a
12656  // struct or something similar.
12657  if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
12658  TUK == TUK_Definition, KWLoc,
12659  Name)) {
12660  bool SafeToContinue
12661  = (PrevTagDecl->getTagKind() != TTK_Enum &&
12662  Kind != TTK_Enum);
12663  if (SafeToContinue)
12664  Diag(KWLoc, diag::err_use_with_wrong_tag)
12665  << Name
12667  PrevTagDecl->getKindName());
12668  else
12669  Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
12670  Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
12671 
12672  if (SafeToContinue)
12673  Kind = PrevTagDecl->getTagKind();
12674  else {
12675  // Recover by making this an anonymous redefinition.
12676  Name = nullptr;
12677  Previous.clear();
12678  Invalid = true;
12679  }
12680  }
12681 
12682  if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
12683  const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
12684 
12685  // If this is an elaborated-type-specifier for a scoped enumeration,
12686  // the 'class' keyword is not necessary and not permitted.
12687  if (TUK == TUK_Reference || TUK == TUK_Friend) {
12688  if (ScopedEnum)
12689  Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
12690  << PrevEnum->isScoped()
12691  << FixItHint::CreateRemoval(ScopedEnumKWLoc);
12692  return PrevTagDecl;
12693  }
12694 
12695  QualType EnumUnderlyingTy;
12696  if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
12697  EnumUnderlyingTy = TI->getType().getUnqualifiedType();
12698  else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
12699  EnumUnderlyingTy = QualType(T, 0);
12700 
12701  // All conflicts with previous declarations are recovered by
12702  // returning the previous declaration, unless this is a definition,
12703  // in which case we want the caller to bail out.
12704  if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
12705  ScopedEnum, EnumUnderlyingTy,
12706  EnumUnderlyingIsImplicit, PrevEnum))
12707  return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
12708  }
12709 
12710  // C++11 [class.mem]p1:
12711  // A member shall not be declared twice in the member-specification,
12712  // except that a nested class or member class template can be declared
12713  // and then later defined.
12714  if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
12715  S->isDeclScope(PrevDecl)) {
12716  Diag(NameLoc, diag::ext_member_redeclared);
12717  Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
12718  }
12719 
12720  if (!Invalid) {
12721  // If this is a use, just return the declaration we found, unless
12722  // we have attributes.
12723  if (TUK == TUK_Reference || TUK == TUK_Friend) {
12724  if (Attr) {
12725  // FIXME: Diagnose these attributes. For now, we create a new
12726  // declaration to hold them.
12727  } else if (TUK == TUK_Reference &&
12728  (PrevTagDecl->getFriendObjectKind() ==
12729  Decl::FOK_Undeclared ||
12730  PP.getModuleContainingLocation(
12731  PrevDecl->getLocation()) !=
12732  PP.getModuleContainingLocation(KWLoc)) &&
12733  SS.isEmpty()) {
12734  // This declaration is a reference to an existing entity, but
12735  // has different visibility from that entity: it either makes
12736  // a friend visible or it makes a type visible in a new module.
12737  // In either case, create a new declaration. We only do this if
12738  // the declaration would have meant the same thing if no prior
12739  // declaration were found, that is, if it was found in the same
12740  // scope where we would have injected a declaration.
12741  if (!getTagInjectionContext(CurContext)->getRedeclContext()
12742  ->Equals(PrevDecl->getDeclContext()->getRedeclContext()))
12743  return PrevTagDecl;
12744  // This is in the injected scope, create a new declaration in
12745  // that scope.
12746  S = getTagInjectionScope(S, getLangOpts());
12747  } else {
12748  return PrevTagDecl;
12749  }
12750  }
12751 
12752  // Diagnose attempts to redefine a tag.
12753  if (TUK == TUK_Definition) {
12754  if (NamedDecl *Def = PrevTagDecl->getDefinition()) {
12755  // If we're defining a specialization and the previous definition
12756  // is from an implicit instantiation, don't emit an error
12757  // here; we'll catch this in the general case below.
12758  bool IsExplicitSpecializationAfterInstantiation = false;
12759  if (isExplicitSpecialization) {
12760  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
12761  IsExplicitSpecializationAfterInstantiation =
12762  RD->getTemplateSpecializationKind() !=
12764  else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
12765  IsExplicitSpecializationAfterInstantiation =
12766  ED->getTemplateSpecializationKind() !=
12768  }
12769 
12770  NamedDecl *Hidden = nullptr;
12771  if (SkipBody && getLangOpts().CPlusPlus &&
12772  !hasVisibleDefinition(Def, &Hidden)) {
12773  // There is a definition of this tag, but it is not visible. We
12774  // explicitly make use of C++'s one definition rule here, and
12775  // assume that this definition is identical to the hidden one
12776  // we already have. Make the existing definition visible and
12777  // use it in place of this one.
12778  SkipBody->ShouldSkip = true;
12779  makeMergedDefinitionVisible(Hidden, KWLoc);
12780  return Def;
12781  } else if (!IsExplicitSpecializationAfterInstantiation) {
12782  // A redeclaration in function prototype scope in C isn't
12783  // visible elsewhere, so merely issue a warning.
12784  if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
12785  Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
12786  else
12787  Diag(NameLoc, diag::err_redefinition) << Name;
12788  Diag(Def->getLocation(), diag::note_previous_definition);
12789  // If this is a redefinition, recover by making this
12790  // struct be anonymous, which will make any later
12791  // references get the previous definition.
12792  Name = nullptr;
12793  Previous.clear();
12794  Invalid = true;
12795  }
12796  } else {
12797  // If the type is currently being defined, complain
12798  // about a nested redefinition.
12799  auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl();
12800  if (TD->isBeingDefined()) {
12801  Diag(NameLoc, diag::err_nested_redefinition) << Name;
12802  Diag(PrevTagDecl->getLocation(),
12803  diag::note_previous_definition);
12804  Name = nullptr;
12805  Previous.clear();
12806  Invalid = true;
12807  }
12808  }
12809 
12810  // Okay, this is definition of a previously declared or referenced
12811  // tag. We're going to create a new Decl for it.
12812  }
12813 
12814  // Okay, we're going to make a redeclaration. If this is some kind
12815  // of reference, make sure we build the redeclaration in the same DC
12816  // as the original, and ignore the current access specifier.
12817  if (TUK == TUK_Friend || TUK == TUK_Reference) {
12818  SearchDC = PrevTagDecl->getDeclContext();
12819  AS = AS_none;
12820  }
12821  }
12822  // If we get here we have (another) forward declaration or we
12823  // have a definition. Just create a new decl.
12824 
12825  } else {
12826  // If we get here, this is a definition of a new tag type in a nested
12827  // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
12828  // new decl/type. We set PrevDecl to NULL so that the entities
12829  // have distinct types.
12830  Previous.clear();
12831  }
12832  // If we get here, we're going to create a new Decl. If PrevDecl
12833  // is non-NULL, it's a definition of the tag declared by
12834  // PrevDecl. If it's NULL, we have a new definition.
12835 
12836  // Otherwise, PrevDecl is not a tag, but was found with tag
12837  // lookup. This is only actually possible in C++, where a few
12838  // things like templates still live in the tag namespace.
12839  } else {
12840  // Use a better diagnostic if an elaborated-type-specifier
12841  // found the wrong kind of type on the first
12842  // (non-redeclaration) lookup.
12843  if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
12844  !Previous.isForRedeclaration()) {
12845  unsigned Kind = 0;
12846  if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
12847  else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
12848  else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
12849  Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
12850  Diag(PrevDecl->getLocation(), diag::note_declared_at);
12851  Invalid = true;
12852 
12853  // Otherwise, only diagnose if the declaration is in scope.
12854  } else if (!isDeclInScope(DirectPrevDecl, SearchDC, S,
12855  SS.isNotEmpty() || isExplicitSpecialization)) {
12856  // do nothing
12857 
12858  // Diagnose implicit declarations introduced by elaborated types.
12859  } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
12860  unsigned Kind = 0;
12861  if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
12862  else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
12863  else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
12864  Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
12865  Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
12866  Invalid = true;
12867 
12868  // Otherwise it's a declaration. Call out a particularly common
12869  // case here.
12870  } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
12871  unsigned Kind = 0;
12872  if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
12873  Diag(NameLoc, diag::err_tag_definition_of_typedef)
12874  << Name << Kind << TND->getUnderlyingType();
12875  Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
12876  Invalid = true;
12877 
12878  // Otherwise, diagnose.
12879  } else {
12880  // The tag name clashes with something else in the target scope,
12881  // issue an error and recover by making this tag be anonymous.
12882  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
12883  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
12884  Name = nullptr;
12885  Invalid = true;
12886  }
12887 
12888  // The existing declaration isn't relevant to us; we're in a
12889  // new scope, so clear out the previous declaration.
12890  Previous.clear();
12891  }
12892  }
12893 
12894 CreateNewDecl:
12895 
12896  TagDecl *PrevDecl = nullptr;
12897  if (Previous.isSingleResult())
12898  PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
12899 
12900  // If there is an identifier, use the location of the identifier as the
12901  // location of the decl, otherwise use the location of the struct/union
12902  // keyword.
12903  SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
12904 
12905  // Otherwise, create a new declaration. If there is a previous
12906  // declaration of the same entity, the two will be linked via
12907  // PrevDecl.
12908  TagDecl *New;
12909 
12910  bool IsForwardReference = false;
12911  if (Kind == TTK_Enum) {
12912  // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12913  // enum X { A, B, C } D; D should chain to X.
12914  New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
12915  cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
12916  ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
12917  // If this is an undefined enum, warn.
12918  if (TUK != TUK_Definition && !Invalid) {
12919  TagDecl *Def;
12920  if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
12921  cast<EnumDecl>(New)->isFixed()) {
12922  // C++0x: 7.2p2: opaque-enum-declaration.
12923  // Conflicts are diagnosed above. Do nothing.
12924  }
12925  else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
12926  Diag(Loc, diag::ext_forward_ref_enum_def)
12927  << New;
12928  Diag(Def->getLocation(), diag::note_previous_definition);
12929  } else {
12930  unsigned DiagID = diag::ext_forward_ref_enum;
12931  if (getLangOpts().MSVCCompat)
12932  DiagID = diag::ext_ms_forward_ref_enum;
12933  else if (getLangOpts().CPlusPlus)
12934  DiagID = diag::err_forward_ref_enum;
12935  Diag(Loc, DiagID);
12936 
12937  // If this is a forward-declared reference to an enumeration, make a
12938  // note of it; we won't actually be introducing the declaration into
12939  // the declaration context.
12940  if (TUK == TUK_Reference)
12941  IsForwardReference = true;
12942  }
12943  }
12944 
12945  if (EnumUnderlying) {
12946  EnumDecl *ED = cast<EnumDecl>(New);
12947  if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
12948  ED->setIntegerTypeSourceInfo(TI);
12949  else
12950  ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
12951  ED->setPromotionType(ED->getIntegerType());
12952  }
12953  } else {
12954  // struct/union/class
12955 
12956  // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12957  // struct X { int A; } D; D should chain to X.
12958  if (getLangOpts().CPlusPlus) {
12959  // FIXME: Look for a way to use RecordDecl for simple structs.
12960  New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
12961  cast_or_null<CXXRecordDecl>(PrevDecl));
12962 
12963  if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
12964  StdBadAlloc = cast<CXXRecordDecl>(New);
12965  } else
12966  New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
12967  cast_or_null<RecordDecl>(PrevDecl));
12968  }
12969 
12970  // C++11 [dcl.type]p3:
12971  // A type-specifier-seq shall not define a class or enumeration [...].
12972  if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) {
12973  Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
12974  << Context.getTagDeclType(New);
12975  Invalid = true;
12976  }
12977 
12978  // Maybe add qualifier info.
12979  if (SS.isNotEmpty()) {
12980  if (SS.isSet()) {
12981  // If this is either a declaration or a definition, check the
12982  // nested-name-specifier against the current context. We don't do this
12983  // for explicit specializations, because they have similar checking
12984  // (with more specific diagnostics) in the call to
12985  // CheckMemberSpecialization, below.
12986  if (!isExplicitSpecialization &&
12987  (TUK == TUK_Definition || TUK == TUK_Declaration) &&
12988  diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc))
12989  Invalid = true;
12990 
12992  if (TemplateParameterLists.size() > 0) {
12993  New->setTemplateParameterListsInfo(Context, TemplateParameterLists);
12994  }
12995  }
12996  else
12997  Invalid = true;
12998  }
12999 
13000  if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
13001  // Add alignment attributes if necessary; these attributes are checked when
13002  // the ASTContext lays out the structure.
13003  //
13004  // It is important for implementing the correct semantics that this
13005  // happen here (in act on tag decl). The #pragma pack stack is
13006  // maintained as a result of parser callbacks which can occur at
13007  // many points during the parsing of a struct declaration (because
13008  // the #pragma tokens are effectively skipped over during the
13009  // parsing of the struct).
13010  if (TUK == TUK_Definition) {
13011  AddAlignmentAttributesForRecord(RD);
13012  AddMsStructLayoutForRecord(RD);
13013  }
13014  }
13015 
13016  if (ModulePrivateLoc.isValid()) {
13017  if (isExplicitSpecialization)
13018  Diag(New->getLocation(), diag::err_module_private_specialization)
13019  << 2
13020  << FixItHint::CreateRemoval(ModulePrivateLoc);
13021  // __module_private__ does not apply to local classes. However, we only
13022  // diagnose this as an error when the declaration specifiers are
13023  // freestanding. Here, we just ignore the __module_private__.
13024  else if (!SearchDC->isFunctionOrMethod())
13025  New->setModulePrivate();
13026  }
13027 
13028  // If this is a specialization of a member class (of a class template),
13029  // check the specialization.
13030  if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
13031  Invalid = true;
13032 
13033  // If we're declaring or defining a tag in function prototype scope in C,
13034  // note that this type can only be used within the function and add it to
13035  // the list of decls to inject into the function definition scope.
13036  if ((Name || Kind == TTK_Enum) &&
13037  getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
13038  if (getLangOpts().CPlusPlus) {
13039  // C++ [dcl.fct]p6:
13040  // Types shall not be defined in return or parameter types.
13041  if (TUK == TUK_Definition && !IsTypeSpecifier) {
13042  Diag(Loc, diag::err_type_defined_in_param_type)
13043  << Name;
13044  Invalid = true;
13045  }
13046  } else if (!PrevDecl) {
13047  Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
13048  }
13049  DeclsInPrototypeScope.push_back(New);
13050  }
13051 
13052  if (Invalid)
13053  New->setInvalidDecl();
13054 
13055  if (Attr)
13056  ProcessDeclAttributeList(S, New, Attr);
13057 
13058  // Set the lexical context. If the tag has a C++ scope specifier, the
13059  // lexical context will be different from the semantic context.
13060  New->setLexicalDeclContext(CurContext);
13061 
13062  // Mark this as a friend decl if applicable.
13063  // In Microsoft mode, a friend declaration also acts as a forward
13064  // declaration so we always pass true to setObjectOfFriendDecl to make
13065  // the tag name visible.
13066  if (TUK == TUK_Friend)
13067  New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
13068 
13069  // Set the access specifier.
13070  if (!Invalid && SearchDC->isRecord())
13071  SetMemberAccessSpecifier(New, PrevDecl, AS);
13072 
13073  if (TUK == TUK_Definition)
13074  New->startDefinition();
13075 
13076  // If this has an identifier, add it to the scope stack.
13077  if (TUK == TUK_Friend) {
13078  // We might be replacing an existing declaration in the lookup tables;
13079  // if so, borrow its access specifier.
13080  if (PrevDecl)
13081  New->setAccess(PrevDecl->getAccess());
13082 
13083  DeclContext *DC = New->getDeclContext()->getRedeclContext();
13084  DC->makeDeclVisibleInContext(New);
13085  if (Name) // can be null along some error paths
13086  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
13087  PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
13088  } else if (Name) {
13089  S = getNonFieldDeclScope(S);
13090  PushOnScopeChains(New, S, !IsForwardReference);
13091  if (IsForwardReference)
13092  SearchDC->makeDeclVisibleInContext(New);
13093  } else {
13094  CurContext->addDecl(New);
13095  }
13096 
13097  // If this is the C FILE type, notify the AST context.
13098  if (IdentifierInfo *II = New->getIdentifier())
13099  if (!New->isInvalidDecl() &&
13100  New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
13101  II->isStr("FILE"))
13102  Context.setFILEDecl(New);
13103 
13104  if (PrevDecl)
13105  mergeDeclAttributes(New, PrevDecl);
13106 
13107  // If there's a #pragma GCC visibility in scope, set the visibility of this
13108  // record.
13109  AddPushedVisibilityAttribute(New);
13110 
13111  OwnedDecl = true;
13112  // In C++, don't return an invalid declaration. We can't recover well from
13113  // the cases where we make the type anonymous.
13114  return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New;
13115 }
13116 
13118  AdjustDeclIfTemplate(TagD);
13119  TagDecl *Tag = cast<TagDecl>(TagD);
13120 
13121  // Enter the tag context.
13122  PushDeclContext(S, Tag);
13123 
13124  ActOnDocumentableDecl(TagD);
13125 
13126  // If there's a #pragma GCC visibility in scope, set the visibility of this
13127  // record.
13128  AddPushedVisibilityAttribute(Tag);
13129 }
13130 
13132  assert(isa<ObjCContainerDecl>(IDecl) &&
13133  "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
13134  DeclContext *OCD = cast<DeclContext>(IDecl);
13135  assert(getContainingDC(OCD) == CurContext &&
13136  "The next DeclContext should be lexically contained in the current one.");
13137  CurContext = OCD;
13138  return IDecl;
13139 }
13140 
13142  SourceLocation FinalLoc,
13143  bool IsFinalSpelledSealed,
13144  SourceLocation LBraceLoc) {
13145  AdjustDeclIfTemplate(TagD);
13146  CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
13147 
13148  FieldCollector->StartClass();
13149 
13150  if (!Record->getIdentifier())
13151  return;
13152 
13153  if (FinalLoc.isValid())
13154  Record->addAttr(new (Context)
13155  FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
13156 
13157  // C++ [class]p2:
13158  // [...] The class-name is also inserted into the scope of the
13159  // class itself; this is known as the injected-class-name. For
13160  // purposes of access checking, the injected-class-name is treated
13161  // as if it were a public member name.
13162  CXXRecordDecl *InjectedClassName
13163  = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
13164  Record->getLocStart(), Record->getLocation(),
13165  Record->getIdentifier(),
13166  /*PrevDecl=*/nullptr,
13167  /*DelayTypeCreation=*/true);
13168  Context.getTypeDeclType(InjectedClassName, Record);
13169  InjectedClassName->setImplicit();
13170  InjectedClassName->setAccess(AS_public);
13171  if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
13172  InjectedClassName->setDescribedClassTemplate(Template);
13173  PushOnScopeChains(InjectedClassName, S);
13174  assert(InjectedClassName->isInjectedClassName() &&
13175  "Broken injected-class-name");
13176 }
13177 
13179  SourceRange BraceRange) {
13180  AdjustDeclIfTemplate(TagD);
13181  TagDecl *Tag = cast<TagDecl>(TagD);
13182  Tag->setBraceRange(BraceRange);
13183 
13184  // Make sure we "complete" the definition even it is invalid.
13185  if (Tag->isBeingDefined()) {
13186  assert(Tag->isInvalidDecl() && "We should already have completed it");
13187  if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
13188  RD->completeDefinition();
13189  }
13190 
13191  if (isa<CXXRecordDecl>(Tag))
13192  FieldCollector->FinishClass();
13193 
13194  // Exit this scope of this tag's definition.
13195  PopDeclContext();
13196 
13197  if (getCurLexicalContext()->isObjCContainer() &&
13198  Tag->getDeclContext()->isFileContext())
13199  Tag->setTopLevelDeclInObjCContainer();
13200 
13201  // Notify the consumer that we've defined a tag.
13202  if (!Tag->isInvalidDecl())
13203  Consumer.HandleTagDeclDefinition(Tag);
13204 }
13205 
13207  // Exit this scope of this interface definition.
13208  PopDeclContext();
13209 }
13210 
13212  assert(DC == CurContext && "Mismatch of container contexts");
13213  OriginalLexicalContext = DC;
13214  ActOnObjCContainerFinishDefinition();
13215 }
13216 
13218  ActOnObjCContainerStartDefinition(cast<Decl>(DC));
13219  OriginalLexicalContext = nullptr;
13220 }
13221 
13223  AdjustDeclIfTemplate(TagD);
13224  TagDecl *Tag = cast<TagDecl>(TagD);
13225  Tag->setInvalidDecl();
13226 
13227  // Make sure we "complete" the definition even it is invalid.
13228  if (Tag->isBeingDefined()) {
13229  if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
13230  RD->completeDefinition();
13231  }
13232 
13233  // We're undoing ActOnTagStartDefinition here, not
13234  // ActOnStartCXXMemberDeclarations, so we don't have to mess with
13235  // the FieldCollector.
13236 
13237  PopDeclContext();
13238 }
13239 
13240 // Note that FieldName may be null for anonymous bitfields.
13242  IdentifierInfo *FieldName,
13243  QualType FieldTy, bool IsMsStruct,
13244  Expr *BitWidth, bool *ZeroWidth) {
13245  // Default to true; that shouldn't confuse checks for emptiness
13246  if (ZeroWidth)
13247  *ZeroWidth = true;
13248 
13249  // C99 6.7.2.1p4 - verify the field type.
13250  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
13251  if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
13252  // Handle incomplete types with specific error.
13253  if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
13254  return ExprError();
13255  if (FieldName)
13256  return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
13257  << FieldName << FieldTy << BitWidth->getSourceRange();
13258  return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
13259  << FieldTy << BitWidth->getSourceRange();
13260  } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
13261  UPPC_BitFieldWidth))
13262  return ExprError();
13263 
13264  // If the bit-width is type- or value-dependent, don't try to check
13265  // it now.
13266  if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
13267  return BitWidth;
13268 
13269  llvm::APSInt Value;
13270  ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
13271  if (ICE.isInvalid())
13272  return ICE;
13273  BitWidth = ICE.get();
13274 
13275  if (Value != 0 && ZeroWidth)
13276  *ZeroWidth = false;
13277 
13278  // Zero-width bitfield is ok for anonymous field.
13279  if (Value == 0 && FieldName)
13280  return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
13281 
13282  if (Value.isSigned() && Value.isNegative()) {
13283  if (FieldName)
13284  return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
13285  << FieldName << Value.toString(10);
13286  return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
13287  << Value.toString(10);
13288  }
13289 
13290  if (!FieldTy->isDependentType()) {
13291  uint64_t TypeStorageSize = Context.getTypeSize(FieldTy);
13292  uint64_t TypeWidth = Context.getIntWidth(FieldTy);
13293  bool BitfieldIsOverwide = Value.ugt(TypeWidth);
13294 
13295  // Over-wide bitfields are an error in C or when using the MSVC bitfield
13296  // ABI.
13297  bool CStdConstraintViolation =
13298  BitfieldIsOverwide && !getLangOpts().CPlusPlus;
13299  bool MSBitfieldViolation =
13300  Value.ugt(TypeStorageSize) &&
13301  (IsMsStruct || Context.getTargetInfo().getCXXABI().isMicrosoft());
13302  if (CStdConstraintViolation || MSBitfieldViolation) {
13303  unsigned DiagWidth =
13304  CStdConstraintViolation ? TypeWidth : TypeStorageSize;
13305  if (FieldName)
13306  return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
13307  << FieldName << (unsigned)Value.getZExtValue()
13308  << !CStdConstraintViolation << DiagWidth;
13309 
13310  return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_width)
13311  << (unsigned)Value.getZExtValue() << !CStdConstraintViolation
13312  << DiagWidth;
13313  }
13314 
13315  // Warn on types where the user might conceivably expect to get all
13316  // specified bits as value bits: that's all integral types other than
13317  // 'bool'.
13318  if (BitfieldIsOverwide && !FieldTy->isBooleanType()) {
13319  if (FieldName)
13320  Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
13321  << FieldName << (unsigned)Value.getZExtValue()
13322  << (unsigned)TypeWidth;
13323  else
13324  Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_width)
13325  << (unsigned)Value.getZExtValue() << (unsigned)TypeWidth;
13326  }
13327  }
13328 
13329  return BitWidth;
13330 }
13331 
13332 /// ActOnField - Each field of a C struct/union is passed into this in order
13333 /// to create a FieldDecl object for it.
13335  Declarator &D, Expr *BitfieldWidth) {
13336  FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
13337  DeclStart, D, static_cast<Expr*>(BitfieldWidth),
13338  /*InitStyle=*/ICIS_NoInit, AS_public);
13339  return Res;
13340 }
13341 
13342 /// HandleField - Analyze a field of a C struct or a C++ data member.
13343 ///
13345  SourceLocation DeclStart,
13346  Declarator &D, Expr *BitWidth,
13347  InClassInitStyle InitStyle,
13348  AccessSpecifier AS) {
13349  IdentifierInfo *II = D.getIdentifier();
13350  SourceLocation Loc = DeclStart;
13351  if (II) Loc = D.getIdentifierLoc();
13352 
13353  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13354  QualType T = TInfo->getType();
13355  if (getLangOpts().CPlusPlus) {
13356  CheckExtraCXXDefaultArguments(D);
13357 
13358  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
13359  UPPC_DataMemberType)) {
13360  D.setInvalidType();
13361  T = Context.IntTy;
13362  TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
13363  }
13364  }
13365 
13366  // TR 18037 does not allow fields to be declared with address spaces.
13367  if (T.getQualifiers().hasAddressSpace()) {
13368  Diag(Loc, diag::err_field_with_address_space);
13369  D.setInvalidType();
13370  }
13371 
13372  // OpenCL v1.2 s6.9b,r & OpenCL v2.0 s6.12.5 - The following types cannot be
13373  // used as structure or union field: image, sampler, event or block types.
13374  if (LangOpts.OpenCL && (T->isEventT() || T->isImageType() ||
13375  T->isSamplerT() || T->isBlockPointerType())) {
13376  Diag(Loc, diag::err_opencl_type_struct_or_union_field) << T;
13377  D.setInvalidType();
13378  }
13379 
13380  DiagnoseFunctionSpecifiers(D.getDeclSpec());
13381 
13382  if (D.getDeclSpec().isInlineSpecified())
13383  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
13384  << getLangOpts().CPlusPlus1z;
13387  diag::err_invalid_thread)
13388  << DeclSpec::getSpecifierName(TSCS);
13389 
13390  // Check to see if this name was declared as a member previously
13391  NamedDecl *PrevDecl = nullptr;
13392  LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
13393  LookupName(Previous, S);
13394  switch (Previous.getResultKind()) {
13395  case LookupResult::Found:
13397  PrevDecl = Previous.getAsSingle<NamedDecl>();
13398  break;
13399 
13401  PrevDecl = Previous.getRepresentativeDecl();
13402  break;
13403 
13407  break;
13408  }
13409  Previous.suppressDiagnostics();
13410 
13411  if (PrevDecl && PrevDecl->isTemplateParameter()) {
13412  // Maybe we will complain about the shadowed template parameter.
13413  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
13414  // Just pretend that we didn't see the previous declaration.
13415  PrevDecl = nullptr;
13416  }
13417 
13418  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
13419  PrevDecl = nullptr;
13420 
13421  bool Mutable
13423  SourceLocation TSSL = D.getLocStart();
13424  FieldDecl *NewFD
13425  = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
13426  TSSL, AS, PrevDecl, &D);
13427 
13428  if (NewFD->isInvalidDecl())
13429  Record->setInvalidDecl();
13430 
13432  NewFD->setModulePrivate();
13433 
13434  if (NewFD->isInvalidDecl() && PrevDecl) {
13435  // Don't introduce NewFD into scope; there's already something
13436  // with the same name in the same scope.
13437  } else if (II) {
13438  PushOnScopeChains(NewFD, S);
13439  } else
13440  Record->addDecl(NewFD);
13441 
13442  return NewFD;
13443 }
13444 
13445 /// \brief Build a new FieldDecl and check its well-formedness.
13446 ///
13447 /// This routine builds a new FieldDecl given the fields name, type,
13448 /// record, etc. \p PrevDecl should refer to any previous declaration
13449 /// with the same name and in the same scope as the field to be
13450 /// created.
13451 ///
13452 /// \returns a new FieldDecl.
13453 ///
13454 /// \todo The Declarator argument is a hack. It will be removed once
13456  TypeSourceInfo *TInfo,
13457  RecordDecl *Record, SourceLocation Loc,
13458  bool Mutable, Expr *BitWidth,
13459  InClassInitStyle InitStyle,
13460  SourceLocation TSSL,
13461  AccessSpecifier AS, NamedDecl *PrevDecl,
13462  Declarator *D) {
13463  IdentifierInfo *II = Name.getAsIdentifierInfo();
13464  bool InvalidDecl = false;
13465  if (D) InvalidDecl = D->isInvalidType();
13466 
13467  // If we receive a broken type, recover by assuming 'int' and
13468  // marking this declaration as invalid.
13469  if (T.isNull()) {
13470  InvalidDecl = true;
13471  T = Context.IntTy;
13472  }
13473 
13474  QualType EltTy = Context.getBaseElementType(T);
13475  if (!EltTy->isDependentType()) {
13476  if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
13477  // Fields of incomplete type force their record to be invalid.
13478  Record->setInvalidDecl();
13479  InvalidDecl = true;
13480  } else {
13481  NamedDecl *Def;
13482  EltTy->isIncompleteType(&Def);
13483  if (Def && Def->isInvalidDecl()) {
13484  Record->setInvalidDecl();
13485  InvalidDecl = true;
13486  }
13487  }
13488  }
13489 
13490  // OpenCL v1.2 s6.9.c: bitfields are not supported.
13491  if (BitWidth && getLangOpts().OpenCL) {
13492  Diag(Loc, diag::err_opencl_bitfields);
13493  InvalidDecl = true;
13494  }
13495 
13496  // C99 6.7.2.1p8: A member of a structure or union may have any type other
13497  // than a variably modified type.
13498  if (!InvalidDecl && T->isVariablyModifiedType()) {
13499  bool SizeIsNegative;
13500  llvm::APSInt Oversized;
13501 
13502  TypeSourceInfo *FixedTInfo =
13504  SizeIsNegative,
13505  Oversized);
13506  if (FixedTInfo) {
13507  Diag(Loc, diag::warn_illegal_constant_array_size);
13508  TInfo = FixedTInfo;
13509  T = FixedTInfo->getType();
13510  } else {
13511  if (SizeIsNegative)
13512  Diag(Loc, diag::err_typecheck_negative_array_size);
13513  else if (Oversized.getBoolValue())
13514  Diag(Loc, diag::err_array_too_large)
13515  << Oversized.toString(10);
13516  else
13517  Diag(Loc, diag::err_typecheck_field_variable_size);
13518  InvalidDecl = true;
13519  }
13520  }
13521 
13522  // Fields can not have abstract class types
13523  if (!InvalidDecl && RequireNonAbstractType(Loc, T,
13524  diag::err_abstract_type_in_decl,
13525  AbstractFieldType))
13526  InvalidDecl = true;
13527 
13528  bool ZeroWidth = false;
13529  if (InvalidDecl)
13530  BitWidth = nullptr;
13531  // If this is declared as a bit-field, check the bit-field.
13532  if (BitWidth) {
13533  BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
13534  &ZeroWidth).get();
13535  if (!BitWidth) {
13536  InvalidDecl = true;
13537  BitWidth = nullptr;
13538  ZeroWidth = false;
13539  }
13540  }
13541 
13542  // Check that 'mutable' is consistent with the type of the declaration.
13543  if (!InvalidDecl && Mutable) {
13544  unsigned DiagID = 0;
13545  if (T->isReferenceType())
13546  DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference
13547  : diag::err_mutable_reference;
13548  else if (T.isConstQualified())
13549  DiagID = diag::err_mutable_const;
13550 
13551  if (DiagID) {
13552  SourceLocation ErrLoc = Loc;
13553  if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
13554  ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
13555  Diag(ErrLoc, DiagID);
13556  if (DiagID != diag::ext_mutable_reference) {
13557  Mutable = false;
13558  InvalidDecl = true;
13559  }
13560  }
13561  }
13562 
13563  // C++11 [class.union]p8 (DR1460):
13564  // At most one variant member of a union may have a
13565  // brace-or-equal-initializer.
13566  if (InitStyle != ICIS_NoInit)
13567  checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
13568 
13569  FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
13570  BitWidth, Mutable, InitStyle);
13571  if (InvalidDecl)
13572  NewFD->setInvalidDecl();
13573 
13574  if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
13575  Diag(Loc, diag::err_duplicate_member) << II;
13576  Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
13577  NewFD->setInvalidDecl();
13578  }
13579 
13580  if (!InvalidDecl && getLangOpts().CPlusPlus) {
13581  if (Record->isUnion()) {
13582  if (const RecordType *RT = EltTy->getAs<RecordType>()) {
13583  CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
13584  if (RDecl->getDefinition()) {
13585  // C++ [class.union]p1: An object of a class with a non-trivial
13586  // constructor, a non-trivial copy constructor, a non-trivial
13587  // destructor, or a non-trivial copy assignment operator
13588  // cannot be a member of a union, nor can an array of such
13589  // objects.
13590  if (CheckNontrivialField(NewFD))
13591  NewFD->setInvalidDecl();
13592  }
13593  }
13594 
13595  // C++ [class.union]p1: If a union contains a member of reference type,
13596  // the program is ill-formed, except when compiling with MSVC extensions
13597  // enabled.
13598  if (EltTy->isReferenceType()) {
13599  Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
13600  diag::ext_union_member_of_reference_type :
13601  diag::err_union_member_of_reference_type)
13602  << NewFD->getDeclName() << EltTy;
13603  if (!getLangOpts().MicrosoftExt)
13604  NewFD->setInvalidDecl();
13605  }
13606  }
13607  }
13608 
13609  // FIXME: We need to pass in the attributes given an AST
13610  // representation, not a parser representation.
13611  if (D) {
13612  // FIXME: The current scope is almost... but not entirely... correct here.
13613  ProcessDeclAttributes(getCurScope(), NewFD, *D);
13614 
13615  if (NewFD->hasAttrs())
13616  CheckAlignasUnderalignment(NewFD);
13617  }
13618 
13619  // In auto-retain/release, infer strong retension for fields of
13620  // retainable type.
13621  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
13622  NewFD->setInvalidDecl();
13623 
13624  if (T.isObjCGCWeak())
13625  Diag(Loc, diag::warn_attribute_weak_on_field);
13626 
13627  NewFD->setAccess(AS);
13628  return NewFD;
13629 }
13630 
13632  assert(FD);
13633  assert(getLangOpts().CPlusPlus && "valid check only for C++");
13634 
13635  if (FD->isInvalidDecl() || FD->getType()->isDependentType())
13636  return false;
13637 
13638  QualType EltTy = Context.getBaseElementType(FD->getType());
13639  if (const RecordType *RT = EltTy->getAs<RecordType>()) {
13640  CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
13641  if (RDecl->getDefinition()) {
13642  // We check for copy constructors before constructors
13643  // because otherwise we'll never get complaints about
13644  // copy constructors.
13645 
13646  CXXSpecialMember member = CXXInvalid;
13647  // We're required to check for any non-trivial constructors. Since the
13648  // implicit default constructor is suppressed if there are any
13649  // user-declared constructors, we just need to check that there is a
13650  // trivial default constructor and a trivial copy constructor. (We don't
13651  // worry about move constructors here, since this is a C++98 check.)
13652  if (RDecl->hasNonTrivialCopyConstructor())
13653  member = CXXCopyConstructor;
13654  else if (!RDecl->hasTrivialDefaultConstructor())
13655  member = CXXDefaultConstructor;
13656  else if (RDecl->hasNonTrivialCopyAssignment())
13657  member = CXXCopyAssignment;
13658  else if (RDecl->hasNonTrivialDestructor())
13659  member = CXXDestructor;
13660 
13661  if (member != CXXInvalid) {
13662  if (!getLangOpts().CPlusPlus11 &&
13663  getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
13664  // Objective-C++ ARC: it is an error to have a non-trivial field of
13665  // a union. However, system headers in Objective-C programs
13666  // occasionally have Objective-C lifetime objects within unions,
13667  // and rather than cause the program to fail, we make those
13668  // members unavailable.
13669  SourceLocation Loc = FD->getLocation();
13670  if (getSourceManager().isInSystemHeader(Loc)) {
13671  if (!FD->hasAttr<UnavailableAttr>())
13672  FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
13673  UnavailableAttr::IR_ARCFieldWithOwnership, Loc));
13674  return false;
13675  }
13676  }
13677 
13678  Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
13679  diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
13680  diag::err_illegal_union_or_anon_struct_member)
13681  << FD->getParent()->isUnion() << FD->getDeclName() << member;
13682  DiagnoseNontrivial(RDecl, member);
13683  return !getLangOpts().CPlusPlus11;
13684  }
13685  }
13686  }
13687 
13688  return false;
13689 }
13690 
13691 /// TranslateIvarVisibility - Translate visibility from a token ID to an
13692 /// AST enum value.
13695  switch (ivarVisibility) {
13696  default: llvm_unreachable("Unknown visitibility kind");
13697  case tok::objc_private: return ObjCIvarDecl::Private;
13698  case tok::objc_public: return ObjCIvarDecl::Public;
13699  case tok::objc_protected: return ObjCIvarDecl::Protected;
13700  case tok::objc_package: return ObjCIvarDecl::Package;
13701  }
13702 }
13703 
13704 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
13705 /// in order to create an IvarDecl object for it.
13707  SourceLocation DeclStart,
13708  Declarator &D, Expr *BitfieldWidth,
13710 
13711  IdentifierInfo *II = D.getIdentifier();
13712  Expr *BitWidth = (Expr*)BitfieldWidth;
13713  SourceLocation Loc = DeclStart;
13714  if (II) Loc = D.getIdentifierLoc();
13715 
13716  // FIXME: Unnamed fields can be handled in various different ways, for
13717  // example, unnamed unions inject all members into the struct namespace!
13718 
13719  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13720  QualType T = TInfo->getType();
13721 
13722  if (BitWidth) {
13723  // 6.7.2.1p3, 6.7.2.1p4
13724  BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
13725  if (!BitWidth)
13726  D.setInvalidType();
13727  } else {
13728  // Not a bitfield.
13729 
13730  // validate II.
13731 
13732  }
13733  if (T->isReferenceType()) {
13734  Diag(Loc, diag::err_ivar_reference_type);
13735  D.setInvalidType();
13736  }
13737  // C99 6.7.2.1p8: A member of a structure or union may have any type other
13738  // than a variably modified type.
13739  else if (T->isVariablyModifiedType()) {
13740  Diag(Loc, diag::err_typecheck_ivar_variable_size);
13741  D.setInvalidType();
13742  }
13743 
13744  // Get the visibility (access control) for this ivar.
13746  Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
13748  // Must set ivar's DeclContext to its enclosing interface.
13749  ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
13750  if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
13751  return nullptr;
13752  ObjCContainerDecl *EnclosingContext;
13753  if (ObjCImplementationDecl *IMPDecl =
13754  dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
13755  if (LangOpts.ObjCRuntime.isFragile()) {
13756  // Case of ivar declared in an implementation. Context is that of its class.
13757  EnclosingContext = IMPDecl->getClassInterface();
13758  assert(EnclosingContext && "Implementation has no class interface!");
13759  }
13760  else
13761  EnclosingContext = EnclosingDecl;
13762  } else {
13763  if (ObjCCategoryDecl *CDecl =
13764  dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
13765  if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
13766  Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
13767  return nullptr;
13768  }
13769  }
13770  EnclosingContext = EnclosingDecl;
13771  }
13772 
13773  // Construct the decl.
13774  ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
13775  DeclStart, Loc, II, T,
13776  TInfo, ac, (Expr *)BitfieldWidth);
13777 
13778  if (II) {
13779  NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
13780  ForRedeclaration);
13781  if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
13782  && !isa<TagDecl>(PrevDecl)) {
13783  Diag(Loc, diag::err_duplicate_member) << II;
13784  Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
13785  NewID->setInvalidDecl();
13786  }
13787  }
13788 
13789  // Process attributes attached to the ivar.
13790  ProcessDeclAttributes(S, NewID, D);
13791 
13792  if (D.isInvalidType())
13793  NewID->setInvalidDecl();
13794 
13795  // In ARC, infer 'retaining' for ivars of retainable type.
13796  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
13797  NewID->setInvalidDecl();
13798 
13800  NewID->setModulePrivate();
13801 
13802  if (II) {
13803  // FIXME: When interfaces are DeclContexts, we'll need to add
13804  // these to the interface.
13805  S->AddDecl(NewID);
13806  IdResolver.AddDecl(NewID);
13807  }
13808 
13809  if (LangOpts.ObjCRuntime.isNonFragile() &&
13810  !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
13811  Diag(Loc, diag::warn_ivars_in_interface);
13812 
13813  return NewID;
13814 }
13815 
13816 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for
13817 /// class and class extensions. For every class \@interface and class
13818 /// extension \@interface, if the last ivar is a bitfield of any type,
13819 /// then add an implicit `char :0` ivar to the end of that interface.
13821  SmallVectorImpl<Decl *> &AllIvarDecls) {
13822  if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
13823  return;
13824 
13825  Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
13826  ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
13827 
13828  if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
13829  return;
13830  ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
13831  if (!ID) {
13832  if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
13833  if (!CD->IsClassExtension())
13834  return;
13835  }
13836  // No need to add this to end of @implementation.
13837  else
13838  return;
13839  }
13840  // All conditions are met. Add a new bitfield to the tail end of ivars.
13841  llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
13842  Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
13843 
13844  Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
13845  DeclLoc, DeclLoc, nullptr,
13846  Context.CharTy,
13848  DeclLoc),
13850  true);
13851  AllIvarDecls.push_back(Ivar);
13852 }
13853 
13854 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
13855  ArrayRef<Decl *> Fields, SourceLocation LBrac,
13856  SourceLocation RBrac, AttributeList *Attr) {
13857  assert(EnclosingDecl && "missing record or interface decl");
13858 
13859  // If this is an Objective-C @implementation or category and we have
13860  // new fields here we should reset the layout of the interface since
13861  // it will now change.
13862  if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
13863  ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
13864  switch (DC->getKind()) {
13865  default: break;
13866  case Decl::ObjCCategory:
13867  Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
13868  break;
13869  case Decl::ObjCImplementation:
13870  Context.
13871  ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
13872  break;
13873  }
13874  }
13875 
13876  RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
13877 
13878  // Start counting up the number of named members; make sure to include
13879  // members of anonymous structs and unions in the total.
13880  unsigned NumNamedMembers = 0;
13881  if (Record) {
13882  for (const auto *I : Record->decls()) {
13883  if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
13884  if (IFD->getDeclName())
13885  ++NumNamedMembers;
13886  }
13887  }
13888 
13889  // Verify that all the fields are okay.
13890  SmallVector<FieldDecl*, 32> RecFields;
13891 
13892  bool ARCErrReported = false;
13893  for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
13894  i != end; ++i) {
13895  FieldDecl *FD = cast<FieldDecl>(*i);
13896 
13897  // Get the type for the field.
13898  const Type *FDTy = FD->getType().getTypePtr();
13899 
13900  if (!FD->isAnonymousStructOrUnion()) {
13901  // Remember all fields written by the user.
13902  RecFields.push_back(FD);
13903  }
13904 
13905  // If the field is already invalid for some reason, don't emit more
13906  // diagnostics about it.
13907  if (FD->isInvalidDecl()) {
13908  EnclosingDecl->setInvalidDecl();
13909  continue;
13910  }
13911 
13912  // C99 6.7.2.1p2:
13913  // A structure or union shall not contain a member with
13914  // incomplete or function type (hence, a structure shall not
13915  // contain an instance of itself, but may contain a pointer to
13916  // an instance of itself), except that the last member of a
13917  // structure with more than one named member may have incomplete
13918  // array type; such a structure (and any union containing,
13919  // possibly recursively, a member that is such a structure)
13920  // shall not be a member of a structure or an element of an
13921  // array.
13922  if (FDTy->isFunctionType()) {
13923  // Field declared as a function.
13924  Diag(FD->getLocation(), diag::err_field_declared_as_function)
13925  << FD->getDeclName();
13926  FD->setInvalidDecl();
13927  EnclosingDecl->setInvalidDecl();
13928  continue;
13929  } else if (FDTy->isIncompleteArrayType() && Record &&
13930  ((i + 1 == Fields.end() && !Record->isUnion()) ||
13931  ((getLangOpts().MicrosoftExt ||
13932  getLangOpts().CPlusPlus) &&
13933  (i + 1 == Fields.end() || Record->isUnion())))) {
13934  // Flexible array member.
13935  // Microsoft and g++ is more permissive regarding flexible array.
13936  // It will accept flexible array in union and also
13937  // as the sole element of a struct/class.
13938  unsigned DiagID = 0;
13939  if (Record->isUnion())
13940  DiagID = getLangOpts().MicrosoftExt
13941  ? diag::ext_flexible_array_union_ms
13942  : getLangOpts().CPlusPlus
13943  ? diag::ext_flexible_array_union_gnu
13944  : diag::err_flexible_array_union;
13945  else if (NumNamedMembers < 1)
13946  DiagID = getLangOpts().MicrosoftExt
13947  ? diag::ext_flexible_array_empty_aggregate_ms
13948  : getLangOpts().CPlusPlus
13949  ? diag::ext_flexible_array_empty_aggregate_gnu
13950  : diag::err_flexible_array_empty_aggregate;
13951 
13952  if (DiagID)
13953  Diag(FD->getLocation(), DiagID) << FD->getDeclName()
13954  << Record->getTagKind();
13955  // While the layout of types that contain virtual bases is not specified
13956  // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
13957  // virtual bases after the derived members. This would make a flexible
13958  // array member declared at the end of an object not adjacent to the end
13959  // of the type.
13960  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record))
13961  if (RD->getNumVBases() != 0)
13962  Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
13963  << FD->getDeclName() << Record->getTagKind();
13964  if (!getLangOpts().C99)
13965  Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
13966  << FD->getDeclName() << Record->getTagKind();
13967 
13968  // If the element type has a non-trivial destructor, we would not
13969  // implicitly destroy the elements, so disallow it for now.
13970  //
13971  // FIXME: GCC allows this. We should probably either implicitly delete
13972  // the destructor of the containing class, or just allow this.
13973  QualType BaseElem = Context.getBaseElementType(FD->getType());
13974  if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
13975  Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
13976  << FD->getDeclName() << FD->getType();
13977  FD->setInvalidDecl();
13978  EnclosingDecl->setInvalidDecl();
13979  continue;
13980  }
13981  // Okay, we have a legal flexible array member at the end of the struct.
13982  Record->setHasFlexibleArrayMember(true);
13983  } else if (!FDTy->isDependentType() &&
13984  RequireCompleteType(FD->getLocation(), FD->getType(),
13985  diag::err_field_incomplete)) {
13986  // Incomplete type
13987  FD->setInvalidDecl();
13988  EnclosingDecl->setInvalidDecl();
13989  continue;
13990  } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
13991  if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
13992  // A type which contains a flexible array member is considered to be a
13993  // flexible array member.
13994  Record->setHasFlexibleArrayMember(true);
13995  if (!Record->isUnion()) {
13996  // If this is a struct/class and this is not the last element, reject
13997  // it. Note that GCC supports variable sized arrays in the middle of
13998  // structures.
13999  if (i + 1 != Fields.end())
14000  Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
14001  << FD->getDeclName() << FD->getType();
14002  else {
14003  // We support flexible arrays at the end of structs in
14004  // other structs as an extension.
14005  Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
14006  << FD->getDeclName();
14007  }
14008  }
14009  }
14010  if (isa<ObjCContainerDecl>(EnclosingDecl) &&
14011  RequireNonAbstractType(FD->getLocation(), FD->getType(),
14012  diag::err_abstract_type_in_decl,
14013  AbstractIvarType)) {
14014  // Ivars can not have abstract class types
14015  FD->setInvalidDecl();
14016  }
14017  if (Record && FDTTy->getDecl()->hasObjectMember())
14018  Record->setHasObjectMember(true);
14019  if (Record && FDTTy->getDecl()->hasVolatileMember())
14020  Record->setHasVolatileMember(true);
14021  } else if (FDTy->isObjCObjectType()) {
14022  /// A field cannot be an Objective-c object
14023  Diag(FD->getLocation(), diag::err_statically_allocated_object)
14024  << FixItHint::CreateInsertion(FD->getLocation(), "*");
14026  FD->setType(T);
14027  } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
14028  (!getLangOpts().CPlusPlus || Record->isUnion())) {
14029  // It's an error in ARC if a field has lifetime.
14030  // We don't want to report this in a system header, though,
14031  // so we just make the field unavailable.
14032  // FIXME: that's really not sufficient; we need to make the type
14033  // itself invalid to, say, initialize or copy.
14034  QualType T = FD->getType();
14036  if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
14037  SourceLocation loc = FD->getLocation();
14038  if (getSourceManager().isInSystemHeader(loc)) {
14039  if (!FD->hasAttr<UnavailableAttr>()) {
14040  FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
14041  UnavailableAttr::IR_ARCFieldWithOwnership, loc));
14042  }
14043  } else {
14044  Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
14045  << T->isBlockPointerType() << Record->getTagKind();
14046  }
14047  ARCErrReported = true;
14048  }
14049  } else if (getLangOpts().ObjC1 &&
14050  getLangOpts().getGC() != LangOptions::NonGC &&
14051  Record && !Record->hasObjectMember()) {
14052  if (FD->getType()->isObjCObjectPointerType() ||
14053  FD->getType().isObjCGCStrong())
14054  Record->setHasObjectMember(true);
14055  else if (Context.getAsArrayType(FD->getType())) {
14056  QualType BaseType = Context.getBaseElementType(FD->getType());
14057  if (BaseType->isRecordType() &&
14058  BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
14059  Record->setHasObjectMember(true);
14060  else if (BaseType->isObjCObjectPointerType() ||
14061  BaseType.isObjCGCStrong())
14062  Record->setHasObjectMember(true);
14063  }
14064  }
14065  if (Record && FD->getType().isVolatileQualified())
14066  Record->setHasVolatileMember(true);
14067  // Keep track of the number of named members.
14068  if (FD->getIdentifier())
14069  ++NumNamedMembers;
14070  }
14071 
14072  // Okay, we successfully defined 'Record'.
14073  if (Record) {
14074  bool Completed = false;
14075  if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
14076  if (!CXXRecord->isInvalidDecl()) {
14077  // Set access bits correctly on the directly-declared conversions.
14079  I = CXXRecord->conversion_begin(),
14080  E = CXXRecord->conversion_end(); I != E; ++I)
14081  I.setAccess((*I)->getAccess());
14082  }
14083 
14084  if (!CXXRecord->isDependentType()) {
14085  if (CXXRecord->hasUserDeclaredDestructor()) {
14086  // Adjust user-defined destructor exception spec.
14087  if (getLangOpts().CPlusPlus11)
14088  AdjustDestructorExceptionSpec(CXXRecord,
14089  CXXRecord->getDestructor());
14090  }
14091 
14092  if (!CXXRecord->isInvalidDecl()) {
14093  // Add any implicitly-declared members to this class.
14094  AddImplicitlyDeclaredMembersToClass(CXXRecord);
14095 
14096  // If we have virtual base classes, we may end up finding multiple
14097  // final overriders for a given virtual function. Check for this
14098  // problem now.
14099  if (CXXRecord->getNumVBases()) {
14100  CXXFinalOverriderMap FinalOverriders;
14101  CXXRecord->getFinalOverriders(FinalOverriders);
14102 
14103  for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
14104  MEnd = FinalOverriders.end();
14105  M != MEnd; ++M) {
14106  for (OverridingMethods::iterator SO = M->second.begin(),
14107  SOEnd = M->second.end();
14108  SO != SOEnd; ++SO) {
14109  assert(SO->second.size() > 0 &&
14110  "Virtual function without overridding functions?");
14111  if (SO->second.size() == 1)
14112  continue;
14113 
14114  // C++ [class.virtual]p2:
14115  // In a derived class, if a virtual member function of a base
14116  // class subobject has more than one final overrider the
14117  // program is ill-formed.
14118  Diag(Record->getLocation(), diag::err_multiple_final_overriders)
14119  << (const NamedDecl *)M->first << Record;
14120  Diag(M->first->getLocation(),
14121  diag::note_overridden_virtual_function);
14123  OM = SO->second.begin(),
14124  OMEnd = SO->second.end();
14125  OM != OMEnd; ++OM)
14126  Diag(OM->Method->getLocation(), diag::note_final_overrider)
14127  << (const NamedDecl *)M->first << OM->Method->getParent();
14128 
14129  Record->setInvalidDecl();
14130  }
14131  }
14132  CXXRecord->completeDefinition(&FinalOverriders);
14133  Completed = true;
14134  }
14135  }
14136  }
14137  }
14138 
14139  if (!Completed)
14140  Record->completeDefinition();
14141 
14142  if (Record->hasAttrs()) {
14143  CheckAlignasUnderalignment(Record);
14144 
14145  if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
14146  checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
14147  IA->getRange(), IA->getBestCase(),
14148  IA->getSemanticSpelling());
14149  }
14150 
14151  // Check if the structure/union declaration is a type that can have zero
14152  // size in C. For C this is a language extension, for C++ it may cause
14153  // compatibility problems.
14154  bool CheckForZeroSize;
14155  if (!getLangOpts().CPlusPlus) {
14156  CheckForZeroSize = true;
14157  } else {
14158  // For C++ filter out types that cannot be referenced in C code.
14159  CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
14160  CheckForZeroSize =
14161  CXXRecord->getLexicalDeclContext()->isExternCContext() &&
14162  !CXXRecord->isDependentType() &&
14163  CXXRecord->isCLike();
14164  }
14165  if (CheckForZeroSize) {
14166  bool ZeroSize = true;
14167  bool IsEmpty = true;
14168  unsigned NonBitFields = 0;
14169  for (RecordDecl::field_iterator I = Record->field_begin(),
14170  E = Record->field_end();
14171  (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
14172  IsEmpty = false;
14173  if (I->isUnnamedBitfield()) {
14174  if (I->getBitWidthValue(Context) > 0)
14175  ZeroSize = false;
14176  } else {
14177  ++NonBitFields;
14178  QualType FieldType = I->getType();
14179  if (FieldType->isIncompleteType() ||
14180  !Context.getTypeSizeInChars(FieldType).isZero())
14181  ZeroSize = false;
14182  }
14183  }
14184 
14185  // Empty structs are an extension in C (C99 6.7.2.1p7). They are
14186  // allowed in C++, but warn if its declaration is inside
14187  // extern "C" block.
14188  if (ZeroSize) {
14189  Diag(RecLoc, getLangOpts().CPlusPlus ?
14190  diag::warn_zero_size_struct_union_in_extern_c :
14191  diag::warn_zero_size_struct_union_compat)
14192  << IsEmpty << Record->isUnion() << (NonBitFields > 1);
14193  }
14194 
14195  // Structs without named members are extension in C (C99 6.7.2.1p7),
14196  // but are accepted by GCC.
14197  if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
14198  Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
14199  diag::ext_no_named_members_in_struct_union)
14200  << Record->isUnion();
14201  }
14202  }
14203  } else {
14204  ObjCIvarDecl **ClsFields =
14205  reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
14206  if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
14207  ID->setEndOfDefinitionLoc(RBrac);
14208  // Add ivar's to class's DeclContext.
14209  for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
14210  ClsFields[i]->setLexicalDeclContext(ID);
14211  ID->addDecl(ClsFields[i]);
14212  }
14213  // Must enforce the rule that ivars in the base classes may not be
14214  // duplicates.
14215  if (ID->getSuperClass())
14216  DiagnoseDuplicateIvars(ID, ID->getSuperClass());
14217  } else if (ObjCImplementationDecl *IMPDecl =
14218  dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
14219  assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
14220  for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
14221  // Ivar declared in @implementation never belongs to the implementation.
14222  // Only it is in implementation's lexical context.
14223  ClsFields[I]->setLexicalDeclContext(IMPDecl);
14224  CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
14225  IMPDecl->setIvarLBraceLoc(LBrac);
14226  IMPDecl->setIvarRBraceLoc(RBrac);
14227  } else if (ObjCCategoryDecl *CDecl =
14228  dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
14229  // case of ivars in class extension; all other cases have been
14230  // reported as errors elsewhere.
14231  // FIXME. Class extension does not have a LocEnd field.
14232  // CDecl->setLocEnd(RBrac);
14233  // Add ivar's to class extension's DeclContext.
14234  // Diagnose redeclaration of private ivars.
14235  ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
14236  for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
14237  if (IDecl) {
14238  if (const ObjCIvarDecl *ClsIvar =
14239  IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
14240  Diag(ClsFields[i]->getLocation(),
14241  diag::err_duplicate_ivar_declaration);
14242  Diag(ClsIvar->getLocation(), diag::note_previous_definition);
14243  continue;
14244  }
14245  for (const auto *Ext : IDecl->known_extensions()) {
14246  if (const ObjCIvarDecl *ClsExtIvar
14247  = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
14248  Diag(ClsFields[i]->getLocation(),
14249  diag::err_duplicate_ivar_declaration);
14250  Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
14251  continue;
14252  }
14253  }
14254  }
14255  ClsFields[i]->setLexicalDeclContext(CDecl);
14256  CDecl->addDecl(ClsFields[i]);
14257  }
14258  CDecl->setIvarLBraceLoc(LBrac);
14259  CDecl->setIvarRBraceLoc(RBrac);
14260  }
14261  }
14262 
14263  if (Attr)
14264  ProcessDeclAttributeList(S, Record, Attr);
14265 }
14266 
14267 /// \brief Determine whether the given integral value is representable within
14268 /// the given type T.
14270  llvm::APSInt &Value,
14271  QualType T) {
14272  assert(T->isIntegralType(Context) && "Integral type required!");
14273  unsigned BitWidth = Context.getIntWidth(T);
14274 
14275  if (Value.isUnsigned() || Value.isNonNegative()) {
14277  --BitWidth;
14278  return Value.getActiveBits() <= BitWidth;
14279  }
14280  return Value.getMinSignedBits() <= BitWidth;
14281 }
14282 
14283 // \brief Given an integral type, return the next larger integral type
14284 // (or a NULL type of no such type exists).
14286  // FIXME: Int128/UInt128 support, which also needs to be introduced into
14287  // enum checking below.
14288  assert(T->isIntegralType(Context) && "Integral type required!");
14289  const unsigned NumTypes = 4;
14290  QualType SignedIntegralTypes[NumTypes] = {
14291  Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
14292  };
14293  QualType UnsignedIntegralTypes[NumTypes] = {
14294  Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
14295  Context.UnsignedLongLongTy
14296  };
14297 
14298  unsigned BitWidth = Context.getTypeSize(T);
14299  QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
14300  : UnsignedIntegralTypes;
14301  for (unsigned I = 0; I != NumTypes; ++I)
14302  if (Context.getTypeSize(Types[I]) > BitWidth)
14303  return Types[I];
14304 
14305  return QualType();
14306 }
14307 
14309  EnumConstantDecl *LastEnumConst,
14310  SourceLocation IdLoc,
14311  IdentifierInfo *Id,
14312  Expr *Val) {
14313  unsigned IntWidth = Context.getTargetInfo().getIntWidth();
14314  llvm::APSInt EnumVal(IntWidth);
14315  QualType EltTy;
14316 
14317  if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
14318  Val = nullptr;
14319 
14320  if (Val)
14321  Val = DefaultLvalueConversion(Val).get();
14322 
14323  if (Val) {
14324  if (Enum->isDependentType() || Val->isTypeDependent())
14325  EltTy = Context.DependentTy;
14326  else {
14327  SourceLocation ExpLoc;
14328  if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
14329  !getLangOpts().MSVCCompat) {
14330  // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
14331  // constant-expression in the enumerator-definition shall be a converted
14332  // constant expression of the underlying type.
14333  EltTy = Enum->getIntegerType();
14334  ExprResult Converted =
14335  CheckConvertedConstantExpression(Val, EltTy, EnumVal,
14336  CCEK_Enumerator);
14337  if (Converted.isInvalid())
14338  Val = nullptr;
14339  else
14340  Val = Converted.get();
14341  } else if (!Val->isValueDependent() &&
14342  !(Val = VerifyIntegerConstantExpression(Val,
14343  &EnumVal).get())) {
14344  // C99 6.7.2.2p2: Make sure we have an integer constant expression.
14345  } else {
14346  if (Enum->isFixed()) {
14347  EltTy = Enum->getIntegerType();
14348 
14349  // In Obj-C and Microsoft mode, require the enumeration value to be
14350  // representable in the underlying type of the enumeration. In C++11,
14351  // we perform a non-narrowing conversion as part of converted constant
14352  // expression checking.
14353  if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
14354  if (getLangOpts().MSVCCompat) {
14355  Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
14356  Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
14357  } else
14358  Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
14359  } else
14360  Val = ImpCastExprToType(Val, EltTy,
14361  EltTy->isBooleanType() ?
14362  CK_IntegralToBoolean : CK_IntegralCast)
14363  .get();
14364  } else if (getLangOpts().CPlusPlus) {
14365  // C++11 [dcl.enum]p5:
14366  // If the underlying type is not fixed, the type of each enumerator
14367  // is the type of its initializing value:
14368  // - If an initializer is specified for an enumerator, the
14369  // initializing value has the same type as the expression.
14370  EltTy = Val->getType();
14371  } else {
14372  // C99 6.7.2.2p2:
14373  // The expression that defines the value of an enumeration constant
14374  // shall be an integer constant expression that has a value
14375  // representable as an int.
14376 
14377  // Complain if the value is not representable in an int.
14379  Diag(IdLoc, diag::ext_enum_value_not_int)
14380  << EnumVal.toString(10) << Val->getSourceRange()
14381  << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
14382  else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
14383  // Force the type of the expression to 'int'.
14384  Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
14385  }
14386  EltTy = Val->getType();
14387  }
14388  }
14389  }
14390  }
14391 
14392  if (!Val) {
14393  if (Enum->isDependentType())
14394  EltTy = Context.DependentTy;
14395  else if (!LastEnumConst) {
14396  // C++0x [dcl.enum]p5:
14397  // If the underlying type is not fixed, the type of each enumerator
14398  // is the type of its initializing value:
14399  // - If no initializer is specified for the first enumerator, the
14400  // initializing value has an unspecified integral type.
14401  //
14402  // GCC uses 'int' for its unspecified integral type, as does
14403  // C99 6.7.2.2p3.
14404  if (Enum->isFixed()) {
14405  EltTy = Enum->getIntegerType();
14406  }
14407  else {
14408  EltTy = Context.IntTy;
14409  }
14410  } else {
14411  // Assign the last value + 1.
14412  EnumVal = LastEnumConst->getInitVal();
14413  ++EnumVal;
14414  EltTy = LastEnumConst->getType();
14415 
14416  // Check for overflow on increment.
14417  if (EnumVal < LastEnumConst->getInitVal()) {
14418  // C++0x [dcl.enum]p5:
14419  // If the underlying type is not fixed, the type of each enumerator
14420  // is the type of its initializing value:
14421  //
14422  // - Otherwise the type of the initializing value is the same as
14423  // the type of the initializing value of the preceding enumerator
14424  // unless the incremented value is not representable in that type,
14425  // in which case the type is an unspecified integral type
14426  // sufficient to contain the incremented value. If no such type
14427  // exists, the program is ill-formed.
14429  if (T.isNull() || Enum->isFixed()) {
14430  // There is no integral type larger enough to represent this
14431  // value. Complain, then allow the value to wrap around.
14432  EnumVal = LastEnumConst->getInitVal();
14433  EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
14434  ++EnumVal;
14435  if (Enum->isFixed())
14436  // When the underlying type is fixed, this is ill-formed.
14437  Diag(IdLoc, diag::err_enumerator_wrapped)
14438  << EnumVal.toString(10)
14439  << EltTy;
14440  else
14441  Diag(IdLoc, diag::ext_enumerator_increment_too_large)
14442  << EnumVal.toString(10);
14443  } else {
14444  EltTy = T;
14445  }
14446 
14447  // Retrieve the last enumerator's value, extent that type to the
14448  // type that is supposed to be large enough to represent the incremented
14449  // value, then increment.
14450  EnumVal = LastEnumConst->getInitVal();
14451  EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
14452  EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
14453  ++EnumVal;
14454 
14455  // If we're not in C++, diagnose the overflow of enumerator values,
14456  // which in C99 means that the enumerator value is not representable in
14457  // an int (C99 6.7.2.2p2). However, we support GCC's extension that
14458  // permits enumerator values that are representable in some larger
14459  // integral type.
14460  if (!getLangOpts().CPlusPlus && !T.isNull())
14461  Diag(IdLoc, diag::warn_enum_value_overflow);
14462  } else if (!getLangOpts().CPlusPlus &&
14463  !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
14464  // Enforce C99 6.7.2.2p2 even when we compute the next value.
14465  Diag(IdLoc, diag::ext_enum_value_not_int)
14466  << EnumVal.toString(10) << 1;
14467  }
14468  }
14469  }
14470 
14471  if (!EltTy->isDependentType()) {
14472  // Make the enumerator value match the signedness and size of the
14473  // enumerator's type.
14474  EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
14475  EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
14476  }
14477 
14478  return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
14479  Val, EnumVal);
14480 }
14481 
14483  SourceLocation IILoc) {
14484  if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) ||
14486  return SkipBodyInfo();
14487 
14488  // We have an anonymous enum definition. Look up the first enumerator to
14489  // determine if we should merge the definition with an existing one and
14490  // skip the body.
14491  NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
14493  auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
14494  if (!PrevECD)
14495  return SkipBodyInfo();
14496 
14497  EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
14498  NamedDecl *Hidden;
14499  if (!PrevED->getDeclName() && !hasVisibleDefinition(PrevED, &Hidden)) {
14500  SkipBodyInfo Skip;
14501  Skip.Previous = Hidden;
14502  return Skip;
14503  }
14504 
14505  return SkipBodyInfo();
14506 }
14507 
14508 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
14509  SourceLocation IdLoc, IdentifierInfo *Id,
14511  SourceLocation EqualLoc, Expr *Val) {
14512  EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
14513  EnumConstantDecl *LastEnumConst =
14514  cast_or_null<EnumConstantDecl>(lastEnumConst);
14515 
14516  // The scope passed in may not be a decl scope. Zip up the scope tree until
14517  // we find one that is.
14518  S = getNonFieldDeclScope(S);
14519 
14520  // Verify that there isn't already something declared with this name in this
14521  // scope.
14522  NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
14524  if (PrevDecl && PrevDecl->isTemplateParameter()) {
14525  // Maybe we will complain about the shadowed template parameter.
14526  DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
14527  // Just pretend that we didn't see the previous declaration.
14528  PrevDecl = nullptr;
14529  }
14530 
14531  // C++ [class.mem]p15:
14532  // If T is the name of a class, then each of the following shall have a name
14533  // different from T:
14534  // - every enumerator of every member of class T that is an unscoped
14535  // enumerated type
14536  if (!TheEnumDecl->isScoped())
14537  DiagnoseClassNameShadow(TheEnumDecl->getDeclContext(),
14538  DeclarationNameInfo(Id, IdLoc));
14539 
14540  EnumConstantDecl *New =
14541  CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
14542  if (!New)
14543  return nullptr;
14544 
14545  if (PrevDecl) {
14546  // When in C++, we may get a TagDecl with the same name; in this case the
14547  // enum constant will 'hide' the tag.
14548  assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
14549  "Received TagDecl when not in C++!");
14550  if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S) &&
14551  shouldLinkPossiblyHiddenDecl(PrevDecl, New)) {
14552  if (isa<EnumConstantDecl>(PrevDecl))
14553  Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
14554  else
14555  Diag(IdLoc, diag::err_redefinition) << Id;
14556  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
14557  return nullptr;
14558  }
14559  }
14560 
14561  // Process attributes.
14562  if (Attr) ProcessDeclAttributeList(S, New, Attr);
14563 
14564  // Register this decl in the current scope stack.
14565  New->setAccess(TheEnumDecl->getAccess());
14566  PushOnScopeChains(New, S);
14567 
14568  ActOnDocumentableDecl(New);
14569 
14570  return New;
14571 }
14572 
14573 // Returns true when the enum initial expression does not trigger the
14574 // duplicate enum warning. A few common cases are exempted as follows:
14575 // Element2 = Element1
14576 // Element2 = Element1 + 1
14577 // Element2 = Element1 - 1
14578 // Where Element2 and Element1 are from the same enum.
14580  Expr *InitExpr = ECD->getInitExpr();
14581  if (!InitExpr)
14582  return true;
14583  InitExpr = InitExpr->IgnoreImpCasts();
14584 
14585  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
14586  if (!BO->isAdditiveOp())
14587  return true;
14588  IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
14589  if (!IL)
14590  return true;
14591  if (IL->getValue() != 1)
14592  return true;
14593 
14594  InitExpr = BO->getLHS();
14595  }
14596 
14597  // This checks if the elements are from the same enum.
14598  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
14599  if (!DRE)
14600  return true;
14601 
14602  EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
14603  if (!EnumConstant)
14604  return true;
14605 
14606  if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
14607  Enum)
14608  return true;
14609 
14610  return false;
14611 }
14612 
14613 namespace {
14614 struct DupKey {
14615  int64_t val;
14616  bool isTombstoneOrEmptyKey;
14617  DupKey(int64_t val, bool isTombstoneOrEmptyKey)
14618  : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
14619 };
14620 
14621 static DupKey GetDupKey(const llvm::APSInt& Val) {
14622  return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
14623  false);
14624 }
14625 
14626 struct DenseMapInfoDupKey {
14627  static DupKey getEmptyKey() { return DupKey(0, true); }
14628  static DupKey getTombstoneKey() { return DupKey(1, true); }
14629  static unsigned getHashValue(const DupKey Key) {
14630  return (unsigned)(Key.val * 37);
14631  }
14632  static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
14633  return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
14634  LHS.val == RHS.val;
14635  }
14636 };
14637 } // end anonymous namespace
14638 
14639 // Emits a warning when an element is implicitly set a value that
14640 // a previous element has already been set to.
14642  EnumDecl *Enum,
14643  QualType EnumType) {
14644  if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
14645  return;
14646  // Avoid anonymous enums
14647  if (!Enum->getIdentifier())
14648  return;
14649 
14650  // Only check for small enums.
14651  if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
14652  return;
14653 
14654  typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
14655  typedef SmallVector<ECDVector *, 3> DuplicatesVector;
14656 
14657  typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
14658  typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
14659  ValueToVectorMap;
14660 
14661  DuplicatesVector DupVector;
14662  ValueToVectorMap EnumMap;
14663 
14664  // Populate the EnumMap with all values represented by enum constants without
14665  // an initialier.
14666  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14667  EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
14668 
14669  // Null EnumConstantDecl means a previous diagnostic has been emitted for
14670  // this constant. Skip this enum since it may be ill-formed.
14671  if (!ECD) {
14672  return;
14673  }
14674 
14675  if (ECD->getInitExpr())
14676  continue;
14677 
14678  DupKey Key = GetDupKey(ECD->getInitVal());
14679  DeclOrVector &Entry = EnumMap[Key];
14680 
14681  // First time encountering this value.
14682  if (Entry.isNull())
14683  Entry = ECD;
14684  }
14685 
14686  // Create vectors for any values that has duplicates.
14687  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14688  EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
14689  if (!ValidDuplicateEnum(ECD, Enum))
14690  continue;
14691 
14692  DupKey Key = GetDupKey(ECD->getInitVal());
14693 
14694  DeclOrVector& Entry = EnumMap[Key];
14695  if (Entry.isNull())
14696  continue;
14697 
14698  if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
14699  // Ensure constants are different.
14700  if (D == ECD)
14701  continue;
14702 
14703  // Create new vector and push values onto it.
14704  ECDVector *Vec = new ECDVector();
14705  Vec->push_back(D);
14706  Vec->push_back(ECD);
14707 
14708  // Update entry to point to the duplicates vector.
14709  Entry = Vec;
14710 
14711  // Store the vector somewhere we can consult later for quick emission of
14712  // diagnostics.
14713  DupVector.push_back(Vec);
14714  continue;
14715  }
14716 
14717  ECDVector *Vec = Entry.get<ECDVector*>();
14718  // Make sure constants are not added more than once.
14719  if (*Vec->begin() == ECD)
14720  continue;
14721 
14722  Vec->push_back(ECD);
14723  }
14724 
14725  // Emit diagnostics.
14726  for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
14727  DupVectorEnd = DupVector.end();
14728  DupVectorIter != DupVectorEnd; ++DupVectorIter) {
14729  ECDVector *Vec = *DupVectorIter;
14730  assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
14731 
14732  // Emit warning for one enum constant.
14733  ECDVector::iterator I = Vec->begin();
14734  S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
14735  << (*I)->getName() << (*I)->getInitVal().toString(10)
14736  << (*I)->getSourceRange();
14737  ++I;
14738 
14739  // Emit one note for each of the remaining enum constants with
14740  // the same value.
14741  for (ECDVector::iterator E = Vec->end(); I != E; ++I)
14742  S.Diag((*I)->getLocation(), diag::note_duplicate_element)
14743  << (*I)->getName() << (*I)->getInitVal().toString(10)
14744  << (*I)->getSourceRange();
14745  delete Vec;
14746  }
14747 }
14748 
14749 bool Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
14750  bool AllowMask) const {
14751  assert(ED->hasAttr<FlagEnumAttr>() && "looking for value in non-flag enum");
14752  assert(ED->isCompleteDefinition() && "expected enum definition");
14753 
14754  auto R = FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
14755  llvm::APInt &FlagBits = R.first->second;
14756 
14757  if (R.second) {
14758  for (auto *E : ED->enumerators()) {
14759  const auto &EVal = E->getInitVal();
14760  // Only single-bit enumerators introduce new flag values.
14761  if (EVal.isPowerOf2())
14762  FlagBits = FlagBits.zextOrSelf(EVal.getBitWidth()) | EVal;
14763  }
14764  }
14765 
14766  // A value is in a flag enum if either its bits are a subset of the enum's
14767  // flag bits (the first condition) or we are allowing masks and the same is
14768  // true of its complement (the second condition). When masks are allowed, we
14769  // allow the common idiom of ~(enum1 | enum2) to be a valid enum value.
14770  //
14771  // While it's true that any value could be used as a mask, the assumption is
14772  // that a mask will have all of the insignificant bits set. Anything else is
14773  // likely a logic error.
14774  llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
14775  return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
14776 }
14777 
14779  Decl *EnumDeclX,
14780  ArrayRef<Decl *> Elements,
14781  Scope *S, AttributeList *Attr) {
14782  EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
14784 
14785  if (Attr)
14786  ProcessDeclAttributeList(S, Enum, Attr);
14787 
14788  if (Enum->isDependentType()) {
14789  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14790  EnumConstantDecl *ECD =
14791  cast_or_null<EnumConstantDecl>(Elements[i]);
14792  if (!ECD) continue;
14793 
14794  ECD->setType(EnumType);
14795  }
14796 
14798  return;
14799  }
14800 
14801  // TODO: If the result value doesn't fit in an int, it must be a long or long
14802  // long value. ISO C does not support this, but GCC does as an extension,
14803  // emit a warning.
14804  unsigned IntWidth = Context.getTargetInfo().getIntWidth();
14805  unsigned CharWidth = Context.getTargetInfo().getCharWidth();
14806  unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
14807 
14808  // Verify that all the values are okay, compute the size of the values, and
14809  // reverse the list.
14810  unsigned NumNegativeBits = 0;
14811  unsigned NumPositiveBits = 0;
14812 
14813  // Keep track of whether all elements have type int.
14814  bool AllElementsInt = true;
14815 
14816  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14817  EnumConstantDecl *ECD =
14818  cast_or_null<EnumConstantDecl>(Elements[i]);
14819  if (!ECD) continue; // Already issued a diagnostic.
14820 
14821  const llvm::APSInt &InitVal = ECD->getInitVal();
14822 
14823  // Keep track of the size of positive and negative values.
14824  if (InitVal.isUnsigned() || InitVal.isNonNegative())
14825  NumPositiveBits = std::max(NumPositiveBits,
14826  (unsigned)InitVal.getActiveBits());
14827  else
14828  NumNegativeBits = std::max(NumNegativeBits,
14829  (unsigned)InitVal.getMinSignedBits());
14830 
14831  // Keep track of whether every enum element has type int (very commmon).
14832  if (AllElementsInt)
14833  AllElementsInt = ECD->getType() == Context.IntTy;
14834  }
14835 
14836  // Figure out the type that should be used for this enum.
14837  QualType BestType;
14838  unsigned BestWidth;
14839 
14840  // C++0x N3000 [conv.prom]p3:
14841  // An rvalue of an unscoped enumeration type whose underlying
14842  // type is not fixed can be converted to an rvalue of the first
14843  // of the following types that can represent all the values of
14844  // the enumeration: int, unsigned int, long int, unsigned long
14845  // int, long long int, or unsigned long long int.
14846  // C99 6.4.4.3p2:
14847  // An identifier declared as an enumeration constant has type int.
14848  // The C99 rule is modified by a gcc extension
14849  QualType BestPromotionType;
14850 
14851  bool Packed = Enum->hasAttr<PackedAttr>();
14852  // -fshort-enums is the equivalent to specifying the packed attribute on all
14853  // enum definitions.
14854  if (LangOpts.ShortEnums)
14855  Packed = true;
14856 
14857  if (Enum->isFixed()) {
14858  BestType = Enum->getIntegerType();
14859  if (BestType->isPromotableIntegerType())
14860  BestPromotionType = Context.getPromotedIntegerType(BestType);
14861  else
14862  BestPromotionType = BestType;
14863 
14864  BestWidth = Context.getIntWidth(BestType);
14865  }
14866  else if (NumNegativeBits) {
14867  // If there is a negative value, figure out the smallest integer type (of
14868  // int/long/longlong) that fits.
14869  // If it's packed, check also if it fits a char or a short.
14870  if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
14871  BestType = Context.SignedCharTy;
14872  BestWidth = CharWidth;
14873  } else if (Packed && NumNegativeBits <= ShortWidth &&
14874  NumPositiveBits < ShortWidth) {
14875  BestType = Context.ShortTy;
14876  BestWidth = ShortWidth;
14877  } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
14878  BestType = Context.IntTy;
14879  BestWidth = IntWidth;
14880  } else {
14881  BestWidth = Context.getTargetInfo().getLongWidth();
14882 
14883  if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
14884  BestType = Context.LongTy;
14885  } else {
14886  BestWidth = Context.getTargetInfo().getLongLongWidth();
14887 
14888  if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
14889  Diag(Enum->getLocation(), diag::ext_enum_too_large);
14890  BestType = Context.LongLongTy;
14891  }
14892  }
14893  BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
14894  } else {
14895  // If there is no negative value, figure out the smallest type that fits
14896  // all of the enumerator values.
14897  // If it's packed, check also if it fits a char or a short.
14898  if (Packed && NumPositiveBits <= CharWidth) {
14899  BestType = Context.UnsignedCharTy;
14900  BestPromotionType = Context.IntTy;
14901  BestWidth = CharWidth;
14902  } else if (Packed && NumPositiveBits <= ShortWidth) {
14903  BestType = Context.UnsignedShortTy;
14904  BestPromotionType = Context.IntTy;
14905  BestWidth = ShortWidth;
14906  } else if (NumPositiveBits <= IntWidth) {
14907  BestType = Context.UnsignedIntTy;
14908  BestWidth = IntWidth;
14909  BestPromotionType
14910  = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
14912  } else if (NumPositiveBits <=
14913  (BestWidth = Context.getTargetInfo().getLongWidth())) {
14914  BestType = Context.UnsignedLongTy;
14915  BestPromotionType
14916  = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
14918  } else {
14919  BestWidth = Context.getTargetInfo().getLongLongWidth();
14920  assert(NumPositiveBits <= BestWidth &&
14921  "How could an initializer get larger than ULL?");
14922  BestType = Context.UnsignedLongLongTy;
14923  BestPromotionType
14924  = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
14926  }
14927  }
14928 
14929  // Loop over all of the enumerator constants, changing their types to match
14930  // the type of the enum if needed.
14931  for (auto *D : Elements) {
14932  auto *ECD = cast_or_null<EnumConstantDecl>(D);
14933  if (!ECD) continue; // Already issued a diagnostic.
14934 
14935  // Standard C says the enumerators have int type, but we allow, as an
14936  // extension, the enumerators to be larger than int size. If each
14937  // enumerator value fits in an int, type it as an int, otherwise type it the
14938  // same as the enumerator decl itself. This means that in "enum { X = 1U }"
14939  // that X has type 'int', not 'unsigned'.
14940 
14941  // Determine whether the value fits into an int.
14942  llvm::APSInt InitVal = ECD->getInitVal();
14943 
14944  // If it fits into an integer type, force it. Otherwise force it to match
14945  // the enum decl type.
14946  QualType NewTy;
14947  unsigned NewWidth;
14948  bool NewSign;
14949  if (!getLangOpts().CPlusPlus &&
14950  !Enum->isFixed() &&
14952  NewTy = Context.IntTy;
14953  NewWidth = IntWidth;
14954  NewSign = true;
14955  } else if (ECD->getType() == BestType) {
14956  // Already the right type!
14957  if (getLangOpts().CPlusPlus)
14958  // C++ [dcl.enum]p4: Following the closing brace of an
14959  // enum-specifier, each enumerator has the type of its
14960  // enumeration.
14961  ECD->setType(EnumType);
14962  continue;
14963  } else {
14964  NewTy = BestType;
14965  NewWidth = BestWidth;
14966  NewSign = BestType->isSignedIntegerOrEnumerationType();
14967  }
14968 
14969  // Adjust the APSInt value.
14970  InitVal = InitVal.extOrTrunc(NewWidth);
14971  InitVal.setIsSigned(NewSign);
14972  ECD->setInitVal(InitVal);
14973 
14974  // Adjust the Expr initializer and type.
14975  if (ECD->getInitExpr() &&
14976  !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
14977  ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
14978  CK_IntegralCast,
14979  ECD->getInitExpr(),
14980  /*base paths*/ nullptr,
14981  VK_RValue));
14982  if (getLangOpts().CPlusPlus)
14983  // C++ [dcl.enum]p4: Following the closing brace of an
14984  // enum-specifier, each enumerator has the type of its
14985  // enumeration.
14986  ECD->setType(EnumType);
14987  else
14988  ECD->setType(NewTy);
14989  }
14990 
14991  Enum->completeDefinition(BestType, BestPromotionType,
14992  NumPositiveBits, NumNegativeBits);
14993 
14994  CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
14995 
14996  if (Enum->hasAttr<FlagEnumAttr>()) {
14997  for (Decl *D : Elements) {
14998  EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D);
14999  if (!ECD) continue; // Already issued a diagnostic.
15000 
15001  llvm::APSInt InitVal = ECD->getInitVal();
15002  if (InitVal != 0 && !InitVal.isPowerOf2() &&
15003  !IsValueInFlagEnum(Enum, InitVal, true))
15004  Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range)
15005  << ECD << Enum;
15006  }
15007  }
15008 
15009  // Now that the enum type is defined, ensure it's not been underaligned.
15010  if (Enum->hasAttrs())
15012 }
15013 
15015  SourceLocation StartLoc,
15016  SourceLocation EndLoc) {
15017  StringLiteral *AsmString = cast<StringLiteral>(expr);
15018 
15020  AsmString, StartLoc,
15021  EndLoc);
15022  CurContext->addDecl(New);
15023  return New;
15024 }
15025 
15027  SourceLocation ImportLoc, DeclContext *DC,
15028  bool FromInclude = false) {
15029  SourceLocation ExternCLoc;
15030 
15031  if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
15032  switch (LSD->getLanguage()) {
15034  if (ExternCLoc.isInvalid())
15035  ExternCLoc = LSD->getLocStart();
15036  break;
15038  break;
15039  }
15040  DC = LSD->getParent();
15041  }
15042 
15043  while (isa<LinkageSpecDecl>(DC))
15044  DC = DC->getParent();
15045 
15046  if (!isa<TranslationUnitDecl>(DC)) {
15047  S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))
15048  ? diag::ext_module_import_not_at_top_level_noop
15049  : diag::err_module_import_not_at_top_level_fatal)
15050  << M->getFullModuleName() << DC;
15051  S.Diag(cast<Decl>(DC)->getLocStart(),
15052  diag::note_module_import_not_at_top_level) << DC;
15053  } else if (!M->IsExternC && ExternCLoc.isValid()) {
15054  S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)
15055  << M->getFullModuleName();
15056  S.Diag(ExternCLoc, diag::note_module_import_in_extern_c);
15057  }
15058 }
15059 
15061  return checkModuleImportContext(*this, M, ImportLoc, CurContext);
15062 }
15063 
15065  SourceLocation ImportLoc,
15066  ModuleIdPath Path) {
15067  Module *Mod =
15068  getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
15069  /*IsIncludeDirective=*/false);
15070  if (!Mod)
15071  return true;
15072 
15073  VisibleModules.setVisible(Mod, ImportLoc);
15074 
15075  checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
15076 
15077  // FIXME: we should support importing a submodule within a different submodule
15078  // of the same top-level module. Until we do, make it an error rather than
15079  // silently ignoring the import.
15081  Diag(ImportLoc, getLangOpts().CompilingModule
15082  ? diag::err_module_self_import
15083  : diag::err_module_import_in_implementation)
15085 
15086  SmallVector<SourceLocation, 2> IdentifierLocs;
15087  Module *ModCheck = Mod;
15088  for (unsigned I = 0, N = Path.size(); I != N; ++I) {
15089  // If we've run out of module parents, just drop the remaining identifiers.
15090  // We need the length to be consistent.
15091  if (!ModCheck)
15092  break;
15093  ModCheck = ModCheck->Parent;
15094 
15095  IdentifierLocs.push_back(Path[I].second);
15096  }
15097 
15100  AtLoc.isValid()? AtLoc : ImportLoc,
15101  Mod, IdentifierLocs);
15103  return Import;
15104 }
15105 
15107  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
15108 
15109  // Determine whether we're in the #include buffer for a module. The #includes
15110  // in that buffer do not qualify as module imports; they're just an
15111  // implementation detail of us building the module.
15112  //
15113  // FIXME: Should we even get ActOnModuleInclude calls for those?
15114  bool IsInModuleIncludes =
15115  TUKind == TU_Module &&
15116  getSourceManager().isWrittenInMainFile(DirectiveLoc);
15117 
15118  // Similarly, if we're in the implementation of a module, don't
15119  // synthesize an illegal module import. FIXME: Why not?
15120  bool ShouldAddImport =
15121  !IsInModuleIncludes &&
15122  (getLangOpts().CompilingModule ||
15123  getLangOpts().CurrentModule.empty() ||
15125 
15126  // If this module import was due to an inclusion directive, create an
15127  // implicit import declaration to capture it in the AST.
15128  if (ShouldAddImport) {
15131  DirectiveLoc, Mod,
15132  DirectiveLoc);
15133  TU->addDecl(ImportD);
15135  }
15136 
15138  VisibleModules.setVisible(Mod, DirectiveLoc);
15139 }
15140 
15142  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
15143 
15144  if (getLangOpts().ModulesLocalVisibility)
15145  VisibleModulesStack.push_back(std::move(VisibleModules));
15146  VisibleModules.setVisible(Mod, DirectiveLoc);
15147 }
15148 
15149 void Sema::ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod) {
15150  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
15151 
15152  if (getLangOpts().ModulesLocalVisibility) {
15153  VisibleModules = std::move(VisibleModulesStack.back());
15154  VisibleModulesStack.pop_back();
15155  VisibleModules.setVisible(Mod, DirectiveLoc);
15156  // Leaving a module hides namespace names, so our visible namespace cache
15157  // is now out of date.
15158  VisibleNamespaceCache.clear();
15159  }
15160 }
15161 
15163  Module *Mod) {
15164  // Bail if we're not allowed to implicitly import a module here.
15165  if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery)
15166  return;
15167 
15168  // Create the implicit import declaration.
15171  Loc, Mod, Loc);
15172  TU->addDecl(ImportD);
15174 
15175  // Make the module visible.
15177  VisibleModules.setVisible(Mod, Loc);
15178 }
15179 
15181  IdentifierInfo* AliasName,
15182  SourceLocation PragmaLoc,
15183  SourceLocation NameLoc,
15184  SourceLocation AliasNameLoc) {
15185  NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
15187  AsmLabelAttr *Attr =
15188  AsmLabelAttr::CreateImplicit(Context, AliasName->getName(), AliasNameLoc);
15189 
15190  // If a declaration that:
15191  // 1) declares a function or a variable
15192  // 2) has external linkage
15193  // already exists, add a label attribute to it.
15194  if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
15195  if (isDeclExternC(PrevDecl))
15196  PrevDecl->addAttr(Attr);
15197  else
15198  Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
15199  << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
15200  // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
15201  } else
15202  (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
15203 }
15204 
15206  SourceLocation PragmaLoc,
15207  SourceLocation NameLoc) {
15208  Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
15209 
15210  if (PrevDecl) {
15211  PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
15212  } else {
15213  (void)WeakUndeclaredIdentifiers.insert(
15214  std::pair<IdentifierInfo*,WeakInfo>
15215  (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
15216  }
15217 }
15218 
15220  IdentifierInfo* AliasName,
15221  SourceLocation PragmaLoc,
15222  SourceLocation NameLoc,
15223  SourceLocation AliasNameLoc) {
15224  Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
15226  WeakInfo W = WeakInfo(Name, NameLoc);
15227 
15228  if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
15229  if (!PrevDecl->hasAttr<AliasAttr>())
15230  if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
15231  DeclApplyPragmaWeak(TUScope, ND, W);
15232  } else {
15233  (void)WeakUndeclaredIdentifiers.insert(
15234  std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
15235  }
15236 }
15237 
15239  return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
15240 }
15241 
15243  const Decl *D = cast_or_null<Decl>(getCurObjCLexicalContext());
15244  if (!D)
15245  return AR_Available;
15246 
15247  // If we are within an Objective-C method, we should consult
15248  // both the availability of the method as well as the
15249  // enclosing class. If the class is (say) deprecated,
15250  // the entire method is considered deprecated from the
15251  // purpose of checking if the current context is deprecated.
15252  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
15253  AvailabilityResult R = MD->getAvailability();
15254  if (R != AR_Available)
15255  return R;
15256  D = MD->getClassInterface();
15257  }
15258  // If we are within an Objective-c @implementation, it
15259  // gets the same availability context as the @interface.
15260  else if (const ObjCImplementationDecl *ID =
15261  dyn_cast<ObjCImplementationDecl>(D)) {
15262  D = ID->getClassInterface();
15263  }
15264  // Recover from user error.
15265  return D ? D->getAvailability() : AR_Available;
15266 }
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossibleZeroParamPrototype)
Definition: SemaDecl.cpp:11091
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:266
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:210
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:52
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5375
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:457
param_const_iterator param_begin() const
Definition: DeclObjC.h:354
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2411
void setHasSkippedBody(bool Skipped=true)
Definition: Decl.h:1977
Defines the clang::ASTContext interface.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
Definition: SemaDecl.cpp:2650
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1410
SourceLocation getEnd() const
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
CastKind getCastKind() const
Definition: Expr.h:2680
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:981
CanQualType LongLongTy
Definition: ASTContext.h:901
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
static const Decl * getCanonicalDecl(const Decl *D)
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:2528
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:5193
void setDeclsInPrototypeScope(ArrayRef< NamedDecl * > NewDecls)
Definition: Decl.cpp:2759
bool isVariadic() const
Definition: Type.h:3366
Name lookup found a set of overloaded functions that met the criteria.
Definition: Sema/Lookup.h:47
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1367
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
Definition: ScopeInfo.h:675
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2097
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context, meaning that the members declared in this context are semantically declared in the nearest enclosing non-transparent (opaque) context but are lexically declared in this context.
Definition: DeclBase.cpp:954
iterator begin() const
Definition: DeclBase.h:1103
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:237
bool CheckNontrivialField(FieldDecl *FD)
Definition: SemaDecl.cpp:13631
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
Definition: ASTContext.h:1508
no exception specification
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
Definition: DeclTemplate.h:946
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
Definition: Type.h:5761
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:3321
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2179
EvaluatedExprVisitor - This class visits 'Expr *'s.
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:542
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2134
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2256
A (possibly-)qualified type.
Definition: Type.h:598
ASTConsumer & Consumer
Definition: Sema.h:300
Decl * ActOnIvar(Scope *S, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, tok::ObjCKeywordKind visibility)
ActOnIvar - Each ivar field of an objective-c class is passed into this in order to create an IvarDec...
Definition: SemaDecl.cpp:13706
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1419
Simple class containing the result of Sema::CorrectTypo.
void addThisCapture(bool isNested, SourceLocation Loc, Expr *Cpy, bool ByCopy)
Definition: ScopeInfo.h:877
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1967
capture_const_range captures() const
Definition: DeclCXX.h:1075
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any...
Definition: Decl.cpp:3023
void InstantiatedLocal(const Decl *D, Decl *Inst)
base_class_range bases()
Definition: DeclCXX.h:718
bool isInvalid() const
Definition: Ownership.h:160
const AttributeList * getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1468
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
virtual unsigned getManglingNumber(const CXXMethodDecl *CallOperator)=0
Retrieve the mangling number of a new lambda expression with the given call operator within this cont...
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:541
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Definition: SemaDecl.cpp:15219
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2217
bool isReplaceableGlobalAllocationFunction() const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2578
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:571
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:2986
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2361
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1087
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1269
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1032
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
Definition: SemaDecl.cpp:5354
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
Definition: Decl.h:381
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:254
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1231
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:958
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, SmallVectorImpl< NamedDecl * > &Chaining)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
Definition: SemaDecl.cpp:4129
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2705
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:582
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls)
MergeTypedefNameDecl - We just parsed a typedef 'New' which has the same name and scope as a previous...
Definition: SemaDecl.cpp:1937
Decl * getRepAsDecl() const
Definition: DeclSpec.h:491
static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC)
Determine what kind of declaration we're shadowing.
Definition: SemaDecl.cpp:6518
const LangOptions & getLangOpts() const
Definition: Sema.h:1062
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Sema/Lookup.h:252
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:223
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
Definition: SemaDecl.cpp:14641
ArrayRef< RawComment * > getComments() const
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition: Type.cpp:3663
DeclClass * getAsSingle() const
Definition: Sema/Lookup.h:491
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:931
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Sema/Lookup.h:508
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1140
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:39
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3199
Filter makeFilter()
Create a filter for this result set.
Definition: Sema/Lookup.h:665
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:973
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1453
bool isInitICE() const
Determines whether the initializer is an integral constant expression, or in C++11, whether the initializer is a constant expression.
Definition: Decl.cpp:2207
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:3818
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2879
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2520
const Expr * getInitExpr() const
Definition: Decl.h:2498
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
Definition: Sema.h:2157
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function...
Definition: Decl.cpp:3323
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "...
Definition: Basic/Module.h:178
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2481
unsigned getIntWidth(QualType T) const
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:536
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:3535
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:218
TypedefDecl - Represents the declaration of a typedef-name via the 'typedef' type specifier...
Definition: Decl.h:2681
Defines the SourceManager interface.
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
Definition: ASTContext.h:1432
void ActOnDocumentableDecls(ArrayRef< Decl * > Group)
Definition: SemaDecl.cpp:10752
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
Definition: SemaDecl.cpp:10748
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
Definition: ASTContext.h:1532
static ClassScopeFunctionSpecializationDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, CXXMethodDecl *FD, bool HasExplicitTemplateArgs, TemplateArgumentListInfo TemplateArgs)
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1430
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
A conversion function name, e.g., operator int.
Definition: DeclSpec.h:897
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsExplicitSpecialization)
Perform semantic checking of a new function declaration.
Definition: SemaDecl.cpp:8637
DeclarationName getCXXConversionFunctionName(CanQualType Ty)
getCXXConversionFunctionName - Returns the name of a C++ conversion function for the given Type...
void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope)
Given the set of return statements within a function body, compute the variables that are subject to ...
Definition: SemaDecl.cpp:11382
void erase()
Erase the last element returned from this iterator.
Definition: Sema/Lookup.h:637
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
bool isRecordType() const
Definition: Type.h:5539
static const TST TST_typeofExpr
Definition: DeclSpec.h:295
QualType getUnderlyingType() const
Definition: Decl.h:2649
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1139
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1753
void forgetBuiltin(unsigned ID, IdentifierTable &Table)
Completely forget that the given ID was ever considered a builtin, e.g., because the user provided a ...
Definition: Builtins.cpp:100
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc", where we know the signature a priori.
Definition: Builtins.h:138
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
Definition: Lambda.h:23
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2008
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function...
Definition: SemaDecl.cpp:5292
static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error)
Definition: SemaDecl.cpp:1762
bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like printf in its formatting rules and, if so, set the index to th...
Definition: Builtins.cpp:127
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2155
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1595
Defines the C++ template declaration subclasses.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
StringRef P
bool isVoidPointerType() const
Definition: Type.cpp:385
bool hasNonTrivialDestructor() const
Determine whether this class has a non-trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1275
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:713
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4084
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
Definition: SemaDecl.cpp:2642
void setPure(bool P=true)
Definition: Decl.cpp:2507
bool hasFlexibleArrayMember() const
Definition: Decl.h:3305
void setPreviousDeclaration(FunctionDecl *PrevDecl)
Definition: Decl.cpp:2662
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
SCS getStorageClassSpec() const
Definition: DeclSpec.h:447
void AddDecl(Decl *D)
Definition: Scope.h:275
bool hasDefinition() const
Definition: DeclCXX.h:685
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition: DeclSpec.h:2245
PtrTy get() const
Definition: Ownership.h:164
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:152
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:6981
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn't a simple identifier.
The base class of the type hierarchy.
Definition: Type.h:1281
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1598
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:922
CanQualType LongTy
Definition: ASTContext.h:901
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition: Decl.cpp:3610
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2120
iterator begin() const
Definition: Sema/Lookup.h:319
unsigned getLength() const
Efficiently return the length of this identifier info.
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
Definition: SemaDecl.cpp:2658
static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc)
Definition: SemaDecl.cpp:4226
MapType::iterator iterator
QualType getRecordType(const RecordDecl *Decl) const
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1101
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition: DeclCXX.cpp:1872
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2456
Declaration of a variable template.
const Expr * getInit() const
Definition: Decl.h:1139
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:471
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition: Sema.h:2750
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1162
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:447
virtual void completeDefinition()
completeDefinition - Notes that the definition of this type is now complete.
Definition: Decl.cpp:3776
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1434
decl_iterator begin()
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:563
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:93
bool isBooleanType() const
Definition: Type.h:5743
void ActOnExitFunctionContext()
Definition: SemaDecl.cpp:1214
A container of type source information.
Definition: Decl.h:62
Wrapper for void* pointer.
Definition: Ownership.h:46
Look up of a name that precedes the '::' scope resolution operator in C++.
Definition: Sema.h:2721
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
Definition: SemaDecl.cpp:467
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3153
unsigned getFunctionPrototypeDepth() const
Returns the number of function prototype scopes in this scope chain.
Definition: Scope.h:258
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
Definition: Decl.cpp:3647
bool isBlockPointerType() const
Definition: Type.h:5488
static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T)
Definition: SemaDecl.cpp:3803
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
Definition: DeclSpec.h:1981
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
void PopDeclContext()
Definition: SemaDecl.cpp:1120
void setInitStyle(InitializationStyle Style)
Definition: Decl.h:1184
bool isConceptSpecified() const
Definition: DeclSpec.h:709
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2187
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
Definition: SemaDecl.cpp:6981
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:1599
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
***static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Definition: SemaDecl.cpp:12174
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group, bool TypeMayContainAuto=true)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Definition: SemaDecl.cpp:10700
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:81
This file provides some common utility functions for processing Lambda related AST Constructs...
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class, then each of the following shall have a name different from T:
Definition: SemaDecl.cpp:4806
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:50
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:543
void ActOnObjCReenterContainerContext(DeclContext *DC)
Definition: SemaDecl.cpp:13217
DeclContext::lookup_result Decls
The set of declarations found inside this base class subobject.
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9606
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2090
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
NamedDecl * LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc)
LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
Definition: SemaDecl.cpp:1780
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isExplicit, bool isConstexpr, SourceLocation EndLocation)
Definition: DeclCXX.cpp:2004
bool isFileVarDecl() const
isFileVarDecl - Returns true for file scoped variable declaration.
Definition: Decl.h:1113
static const TST TST_underlyingType
Definition: DeclSpec.h:298
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1624
DiagnosticsEngine & Diags
Definition: Sema.h:301
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
const Expr * getCallee() const
Definition: Expr.h:2188
TLSKind getTLSKind() const
Definition: Decl.cpp:1818
The "union" keyword.
Definition: Type.h:4348
Extra information about a function prototype.
Definition: Type.h:3167
bool isCanonical() const
Definition: Type.h:5303
AutoTypeKeyword getKeyword() const
Definition: Type.h:4102
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1635
field_iterator field_begin() const
Definition: Decl.cpp:3767
bool isCLike() const
True if this class is C-like, without C++-specific features, e.g.
Definition: DeclCXX.cpp:1036
The "__interface" keyword.
Definition: Type.h:4346
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1813
void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context)
Definition: SemaDecl.cpp:1141
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:387
void ActOnObjCTemporaryExitContainerContext(DeclContext *DC)
Invoked when we must temporarily exit the objective-c container scope for parsing/looking-up C constr...
Definition: SemaDecl.cpp:13211
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:998
static const TST TST_interface
Definition: DeclSpec.h:291
bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD)
AddOverriddenMethods - See if a method overrides any in the base classes, and if so, check that it's a valid override and remember it.
Definition: SemaDecl.cpp:7064
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:49
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:4414
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:353
static InitializationKind CreateDirectList(SourceLocation InitLoc)
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value...
Definition: Expr.h:3287
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
Definition: SemaDecl.cpp:7661
bool isImageType() const
Definition: Type.h:5627
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
Definition: SemaDecl.cpp:10795
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
Definition: SemaDecl.cpp:11417
bool isSingleTagDecl() const
Asks if the result is a single tag decl.
Definition: Sema/Lookup.h:514
static QualType getCoreType(QualType Ty)
Definition: SemaDecl.cpp:4666
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1377
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1620
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isUnionType() const
Definition: Type.cpp:391
FormatAttr * mergeFormatAttr(Decl *D, SourceRange Range, IdentifierInfo *Format, int FormatIdx, int FirstArg, unsigned AttrSpellingListIndex)
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1224
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1739
bool isVoidType() const
Definition: Type.h:5680
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
Definition: SemaDecl.cpp:3759
static const TemplateDecl * isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs)
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:2889
static TypeSourceInfo * TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
Definition: SemaDecl.cpp:5254
void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto)
Definition: SemaDecl.cpp:9988
Information about a template-id annotation token.
PipeType - OpenCL20.
Definition: Type.h:5190
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
Definition: SemaDecl.cpp:13344
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:344
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
Definition: SemaInternal.h:37
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
void setCorrectionDecl(NamedDecl *CDecl)
Clears the list of NamedDecls before adding the new one.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:2777
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:11075
unsigned getNumParams() const
Definition: Type.h:3271
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
std::string getFullModuleName() const
Retrieve the full name of this module, including the path from its top-level module.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body (definition).
Definition: Decl.cpp:2454
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2157
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2623
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:952
DeclarationName getName() const
getName - Returns the embedded declaration name.
bool isConst() const
Definition: DeclCXX.h:1777
One of these records is kept for each identifier that is lexed.
iterator end() const
Definition: Sema/Lookup.h:320
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:3146
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7008
ExtInfo withProducesResult(bool producesResult) const
Definition: Type.h:2973
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Sema/Lookup.h:57
bool isScalarType() const
Definition: Type.h:5715
void MarkUnusedFileScopedDecl(const DeclaratorDecl *D)
If it's a file scoped decl that must warn if not used, keep track of it.
Definition: SemaDecl.cpp:1473
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
Definition: Builtins.h:193
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD)
Given that we are within the definition of the given function, will that definition behave like C99's...
Definition: SemaDecl.cpp:5707
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:4567
method_iterator end_overridden_methods() const
Definition: DeclCXX.cpp:1655
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3179
void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S)
Register the given locally-scoped extern "C" declaration so that it can be found later for redeclarat...
Definition: SemaDecl.cpp:5274
static bool isDeclExternC(const Decl *D)
Returns true if given declaration has external C language linkage.
Definition: SemaDecl.cpp:5839
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
Definition: Ownership.h:234
void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld)
MergeVarDeclTypes - We parsed a variable 'New' which has the same name and scope as a previous declar...
Definition: SemaDecl.cpp:3344
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition: Type.cpp:1532
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes, if any.
Definition: Decl.cpp:4137
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:939
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:3729
IdentifierInfo * getCorrectionAsIdentifierInfo() const
AttributeList * getList() const
void setManglingNumber(const NamedDecl *ND, unsigned Number)
Expr * getSizeExpr() const
Definition: Type.h:2623
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
Definition: SemaDecl.cpp:2560
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1789
TypeLoc getPointeeLoc() const
Definition: TypeLoc.h:1115
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
A C++ nested-name-specifier augmented with source location information.
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:1987
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1067
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3276
bool decl_empty() const
Definition: Scope.h:273
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e...
Definition: SemaDecl.cpp:13117
Missing a type from <ucontext.h>
Definition: ASTContext.h:1760
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
Definition: SemaDecl.cpp:11993
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6, C++11 [class.copy]p12)
Definition: DeclCXX.h:1219
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1744
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
Definition: DeclObjC.cpp:56
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
Definition: ASTContext.h:1716
bool isReferenceType() const
Definition: Type.h:5491
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
static const TST TST_class
Definition: DeclSpec.h:292
QualType getReturnType() const
Definition: Decl.h:2034
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
Definition: SemaDecl.cpp:12075
bool isStructureOrClassType() const
Definition: Type.cpp:378
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:899
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2871
void completeDefinition()
Completes the definition of this tag declaration.
Definition: Decl.cpp:3555
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:54
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:914
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, AttributeList *Attr)
Definition: SemaDecl.cpp:14778
void removeConst()
Definition: Type.h:240
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition: Decl.h:521
bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context, will replace the declaration OldD if introduced into scope.
Definition: Decl.cpp:1514
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1837
static bool isIncrementDecrementOp(Opcode Op)
Definition: Expr.h:1729
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:283
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3544
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:935
CXXMethodDecl * getCanonicalDecl() override
Definition: DeclCXX.h:1804
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:678
bool isTranslationUnit() const
Definition: DeclBase.h:1283
bool isNoreturnSpecified() const
Definition: DeclSpec.h:573
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1788
TagKind getTagKind() const
Definition: Decl.h:2930
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:28
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
Definition: Decl.h:1295
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1982
static const TST TST_error
Definition: DeclSpec.h:306
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
DeclarationName getCXXDestructorName(CanQualType Ty)
getCXXDestructorName - Returns the name of a C++ destructor for the given Type.
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
Definition: SemaDecl.cpp:14482
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1112
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:450
SmallVector< Attr *, 2 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
Definition: AttrIterator.h:42
This declaration is definitely a definition.
Definition: Decl.h:1071
static const TST TST_enum
Definition: DeclSpec.h:288
void CheckMain(FunctionDecl *FD, const DeclSpec &D)
Definition: SemaDecl.cpp:8907
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:509
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
Definition: SemaDecl.cpp:11935
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1761
unsigned size() const
Definition: DeclTemplate.h:92
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, AttributeList *Attrs, SourceLocation EqualLoc, Expr *Val)
Definition: SemaDecl.cpp:14508
bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S)
isMicrosoftMissingTypename - In Microsoft mode, within class scope, if a CXXScopeSpec's type is equal...
Definition: SemaDecl.cpp:583
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
Definition: SemaDecl.cpp:11718
Expr * getSubExpr()
Definition: Expr.h:2684
void ClearStorageClassSpecs()
Definition: DeclSpec.h:461
bool isForRedeclaration() const
True if this lookup is just looking for an existing declaration.
Definition: Sema/Lookup.h:262
unsigned getRegParm() const
Definition: Type.h:2948
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
Declaration of a function specialization at template class scope.
Decl * ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
Definition: SemaDecl.cpp:12260
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1199
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1119
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Sema/Lookup.h:39
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
Definition: SemaDecl.cpp:5816
Describes a module or submodule.
Definition: Basic/Module.h:47
IdentifierTable & Idents
Definition: ASTContext.h:459
bool isThisDeclarationADefinition() const
isThisDeclarationADefinition() - Return true if this declaration is a completion definition of the ty...
Definition: Decl.h:2865
void diagnoseMisplacedModuleImport(Module *M, SourceLocation ImportLoc)
Check if module import may be found in the current context, emit error if not.
Definition: SemaDecl.cpp:15060
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:947
RawCommentList & getRawCommentList()
Definition: ASTContext.h:692
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:105
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
Definition: Decl.h:989
Expr * getLHS() const
Definition: Expr.h:2943
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Decl.cpp:1009
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:399
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:1858
unsigned getRegParmType() const
Definition: Type.h:3012
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:170
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:1991
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:947
Describes an C or C++ initializer list.
Definition: Expr.h:3746
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:884
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
QualType getParenType(QualType NamedType) const
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
Definition: DeclBase.cpp:1542
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:470
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:496
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:588
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, SourceRange Range, TypeVisibilityAttr::VisibilityType Vis, unsigned AttrSpellingListIndex)
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
Definition: SemaDecl.cpp:2427
MinSizeAttr * mergeMinSizeAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:901
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
static void filterNonConflictingPreviousTypedefDecls(Sema &S, TypedefNameDecl *Decl, LookupResult &Previous)
Typedef declarations don't have linkage, but they still denote the same entity if their types are the...
Definition: SemaDecl.cpp:1858
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2004
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
A convenient class for passing around template argument information.
Definition: TemplateBase.h:523
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition: Decl.h:1036
void setcudaConfigureCallDecl(FunctionDecl *FD)
Definition: ASTContext.h:1098
Scope * getNonFieldDeclScope(Scope *S)
getNonFieldDeclScope - Retrieves the innermost scope, starting from S, where a non-field would be dec...
Definition: SemaDecl.cpp:1736
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old)
Merge alignment attributes from Old to New, taking into account the special semantics of C11's _Align...
Definition: SemaDecl.cpp:2139
bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
DeclarationNameInfo getNameInfo() const
Definition: Expr.h:1021
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
QualType getReturnType() const
Definition: Type.h:3009
Wrapper for source info for functions.
Definition: TypeLoc.h:1255
static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, Sema &S)
Definition: SemaDecl.cpp:11187
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
Definition: SemaDecl.cpp:9951
SCS
storage-class-specifier
Definition: DeclSpec.h:232
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
Definition: Decl.cpp:4080
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:1838
AmbiguityKind getAmbiguityKind() const
Definition: Sema/Lookup.h:310
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:1853
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition: Decl.cpp:1896
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
Definition: SemaDecl.cpp:5849
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
field_range fields() const
Definition: Decl.h:3382
Decl * ActOnObjCContainerStartDefinition(Decl *IDecl)
Definition: SemaDecl.cpp:13131
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
Definition: SemaDecl.cpp:201
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3718
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1219
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:217
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
Definition: SemaDecl.cpp:4834
static bool isRecordType(QualType T)
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2569
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2897
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2262
void setHasObjectMember(bool val)
Definition: Decl.h:3326
An implicit 'self' parameter.
Definition: DeclSpec.h:909
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:147
static OpenCLParamType getOpenCLKernelParameterType(QualType PT)
Definition: SemaDecl.cpp:7489
static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition)
Definition: SemaDecl.cpp:5594
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
QualType withoutLocalFastQualifiers() const
Definition: Type.h:820
void setHasImplicitReturnZero(bool IRZ)
Definition: Decl.h:1865
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
Module * Parent
The parent of this module.
Definition: Basic/Module.h:57
static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, DeclContext *NewDC)
Determine whether a tag originally declared in context OldDC can be redeclared with an unqualfied nam...
Definition: SemaDecl.cpp:12211
child_range children()
Definition: Expr.h:3908
bool isOverloadedOperator() const
isOverloadedOperator - Whether this function declaration represents an C++ overloaded operator...
Definition: Decl.h:2093
LabelStmt * getStmt() const
Definition: Decl.h:449
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2448
void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
The parser has processed a module import translated from a #include or similar preprocessing directiv...
Definition: SemaDecl.cpp:15106
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:6208
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
Definition: SemaDecl.cpp:15014
CXXRecordDecl * getCanonicalDecl() override
Definition: DeclCXX.h:654
void setTrivial(bool IT)
Definition: Decl.h:1849
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:3115
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition: Type.cpp:77
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
void DiagnoseUnusedDecl(const NamedDecl *ND)
DiagnoseUnusedDecl - Emit warnings about declarations that are not used unless they are marked attr(u...
Definition: SemaDecl.cpp:1594
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
bool hasUnrecoverableErrorOccurred() const
Definition: Scope.h:318
int hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)
Return the version number associated with the attribute if we recognize and implement the attribute s...
Definition: Attributes.cpp:6
bool isStructureType() const
Definition: Type.cpp:363
SourceLocation getConceptSpecLoc() const
Definition: DeclSpec.h:710
void setRedeclarationKind(Sema::RedeclarationKind RK)
Change this lookup's redeclaration kind.
Definition: Sema/Lookup.h:556
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1892
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
Definition: SemaDecl.cpp:2246
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
static Scope * getTagInjectionScope(Scope *S, const LangOptions &LangOpts)
Find the Scope in which a tag is implicitly declared if we see an elaborated type specifier in the sp...
Definition: SemaDecl.cpp:12240
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
Definition: SemaDecl.cpp:1898
void UpdateExprRep(Expr *Rep)
Definition: DeclSpec.h:672
void CheckCompleteVariableDeclaration(VarDecl *var)
Definition: SemaDecl.cpp:10295
void CheckVariableDeclarationType(VarDecl *NewVD)
Definition: SemaDecl.cpp:6760
SourceLocation getLocation() const
Definition: Attr.h:94
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:980
iterator end() const
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1800
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:720
bool isExternInLinkageSpec() const
Definition: DeclSpec.h:451
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name...
Definition: Builtins.h:166
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition: Decl.cpp:1679
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3068
void CheckMSVCRTEntryPoint(FunctionDecl *FD)
Definition: SemaDecl.cpp:9054
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:11437
Represents an ObjC class declaration.
Definition: DeclObjC.h:1091
void revertBuiltin()
Revert the identifier to a non-builtin identifier.
Represents a linkage specification.
Definition: DeclCXX.h:2523
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:503
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Sema/Lookup.h:410
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:2713
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:502
bool empty() const
Definition: Type.h:377
detail::InMemoryDirectory::const_iterator I
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared...
Definition: Sema.h:695
static bool isUsingDecl(NamedDecl *D)
Definition: SemaDecl.cpp:1350
CanQualType UnsignedCharTy
Definition: ASTContext.h:902
QualType getType() const
Definition: Decl.h:599
bool isInvalid() const
const LangOptions & LangOpts
Definition: Sema.h:297
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1720
UnionParsedType ConstructorName
When Kind == IK_ConstructorName, the class-name of the type whose constructor is being referenced...
Definition: DeclSpec.h:943
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:53
void DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool AllowClassTemplates=false)
Definition: SemaDecl.cpp:599
void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL, bool IncludeCXX11Attributes=true)
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:2756
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
This object can be modified without requiring retains or releases.
Definition: Type.h:138
SourceRange getRange() const
Definition: DeclSpec.h:68
bool isDefined(const FunctionDecl *&Definition) const
isDefined - Returns true if the function is defined at all, including a deleted definition.
Definition: Decl.cpp:2479
param_iterator param_begin()
Definition: Decl.h:2000
unsigned getMSLastManglingNumber() const
Definition: Scope.h:297
void setHasInheritedPrototype(bool P=true)
Definition: Decl.h:1880
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
field_iterator field_end() const
Definition: Decl.h:3385
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:1871
Class that aids in the construction of nested-name-specifiers along with source-location information ...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:64
ImplicitCaptureStyle ImpCaptureStyle
Definition: ScopeInfo.h:408
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:6955
static const Decl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2321
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:1841
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1007
bool isStatic() const
Definition: DeclCXX.cpp:1475
bool isUnion() const
Definition: Decl.h:2939
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
void completeDefinition(QualType NewType, QualType PromotionType, unsigned NumPositiveBits, unsigned NumNegativeBits)
completeDefinition - When created, the EnumDecl corresponds to a forward-declared enum...
Definition: Decl.cpp:3653
static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)
Create a new module import declaration.
Definition: Decl.cpp:4245
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3183
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3170
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1736
void setLazyBody(uint64_t Offset)
Definition: Decl.h:1826
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:349
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:5858
ExtInfo getExtInfo() const
Definition: Type.h:3018
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:263
void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name)
Make the given externally-produced declaration visible at the top level scope.
Definition: SemaDecl.cpp:1304
Merge availability attributes for an implementation of a protocol requirement.
Definition: Sema.h:2160
llvm::APInt getValue() const
Definition: Expr.h:1248
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2066
bool Mutable
Whether this is a mutable lambda.
Definition: ScopeInfo.h:686
TST getTypeSpecType() const
Definition: DeclSpec.h:479
SmallVector< ReturnStmt *, 4 > Returns
The list of return statements that occur within the function or block, if there is any chance of appl...
Definition: ScopeInfo.h:153
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Sema/Lookup.h:237
QualType getParamType(unsigned i) const
Definition: Type.h:3272
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit, bool TypeMayContainAuto)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:9517
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:119
bool isReturnsTwice(unsigned ID) const
Return true if we know this builtin can return twice.
Definition: Builtins.h:119
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2593
SourceLocation getModulePrivateSpecLoc() const
Definition: DeclSpec.h:704
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:107
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if 'E', which is an expression that is about to be modified, refers to a shadowing declaration...
Definition: SemaDecl.cpp:6621
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one. ...
Definition: SemaDecl.cpp:2517
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1009
TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S)
isTagName() - This method is called for error recovery purposes only to determine if the specified na...
Definition: SemaDecl.cpp:550
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5487
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:646
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:607
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1652
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:701
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:462
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1247
SourceLocation getLBracketLoc() const
Definition: TypeLoc.h:1363
bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, bool MergeTypeWithOld)
MergeFunctionDecl - We just parsed a function 'New' from declarator D which has the same name and sco...
Definition: SemaDecl.cpp:2739
bool isPure(unsigned ID) const
Return true if this function has no side effects.
Definition: Builtins.h:98
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1643
ASTContext * Context
std::vector< bool > & Stack
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
Definition: Decl.h:2851
ArrayRef< NamedDecl * > getDeclsInPrototypeScope() const
Definition: Decl.h:2023
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
Captures information about a #pragma weak directive.
Definition: Weak.h:25
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2063
const CXXMethodDecl *const * method_iterator
Definition: DeclCXX.h:1828
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
bool isFunctionPointerType() const
Definition: Type.h:5500
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:315
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
static NamedDecl * DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S)
Generate diagnostics for an invalid function redeclaration.
Definition: SemaDecl.cpp:7163
static bool isDeclRep(TST T)
Definition: DeclSpec.h:413
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:540
void setVisible(Module *M, SourceLocation Loc, VisibleCallback Vis=[](Module *){}, ConflictCallback Cb=[](ArrayRef< Module * >, Module *, StringRef){})
Make a specific module visible.
bool canKeyFunctionBeInline() const
Can an out-of-line inline function serve as a key function?
Definition: TargetCXXABI.h:267
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:1972
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1722
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
unsigned getNumExprs() const
Definition: Expr.h:4350
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1909
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1230
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Definition: ScopeInfo.h:672
bool isGlobal() const
Determines whether this is a global function.
Definition: Decl.cpp:2635
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:39
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
Definition: Builtins.h:109
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:155
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2276
const Type * getTypeForDecl() const
Definition: Decl.h:2590
SourceLocation getRBracketLoc() const
Definition: TypeLoc.h:1370
unsigned getTypeQualifiers() const
Definition: DeclCXX.h:1854
QualType getPointeeType() const
Definition: Type.h:2300
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:5749
Expr - This represents one expression.
Definition: Expr.h:105
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Sema/Lookup.h:247
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:2701
StringRef getName() const
Return the actual identifier string.
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e...
Definition: SemaDecl.cpp:3714
const char * getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Definition: Builtins.h:83
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
Definition: SemaDecl.cpp:695
Represents a character-granular source range.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4370
DLLImportAttr * mergeDLLImportAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:544
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
void ResetObjCLayout(const ObjCContainerDecl *CD)
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:309
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:508
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition: Type.h:3862
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:249
StateNode * Previous
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
Definition: SemaDecl.cpp:6729
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
bool isFunctionDefinition() const
Definition: DeclSpec.h:2241
static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Definition: Lexer.cpp:1183
unsigned SymbolLocations[3]
The source locations of the individual tokens that name the operator, e.g., the "new", "[", and "]" tokens in operator new [].
Definition: DeclSpec.h:923
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Sema/Lookup.h:589
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:981
bool isModuleVisible(Module *M)
Definition: Sema.h:1406
bool isVirtual() const
Definition: DeclCXX.h:1780
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum)
Definition: SemaDecl.cpp:14579
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2414
void setInit(Expr *I)
Definition: Decl.cpp:2081
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:886
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Sema/Lookup.h:501
bool isObjCGCWeak() const
true when Type is objc's weak.
Definition: Type.h:999
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
Definition: DeclSpec.h:549
bool isVariableArrayType() const
Definition: Type.h:5530
Decl * BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record)
BuildMicrosoftCAnonymousStruct - Handle the declaration of an Microsoft C anonymous structure...
Definition: SemaDecl.cpp:4514
Defines the clang::Preprocessor interface.
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
bool isInherited() const
Definition: Attr.h:98
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2011
bool getNoReturn() const
Definition: Type.h:2945
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3280
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &O)
Definition: Type.h:3176
static void CheckPoppedLabel(LabelDecl *L, Sema &S)
Definition: SemaDecl.cpp:1619
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:689
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:543
Name lookup results in an ambiguity because an entity with a tag name was hidden by an entity with an...
Definition: Sema/Lookup.h:119
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: Redeclarable.h:163
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
Definition: Specifiers.h:252
void CheckAlignasUnderalignment(Decl *D)
This declaration is a tentative definition.
Definition: Decl.h:1070
bool isFloatingType() const
Definition: Type.cpp:1783
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:350
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
Definition: ASTContext.h:1419
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
Definition: SemaDecl.cpp:14285
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2391
CanQualType ShortTy
Definition: ASTContext.h:901
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:753
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Definition: ASTConsumer.h:110
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
bool isWrittenInMainFile(SourceLocation Loc) const
Returns true if the spelling location for the given location is in the main file buffer.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
enum clang::DeclaratorChunk::@185 Kind
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name...
Definition: SemaDecl.cpp:5394
bool isMSAsmLabel() const
Definition: Decl.h:459
bool isFunctionNoProtoType() const
Definition: Type.h:1661
bool isObjCIdType() const
Definition: Type.h:5578
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
Definition: SemaDecl.cpp:13334
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:1409
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2083
void UpdateTypeRep(ParsedType Rep)
Definition: DeclSpec.h:668
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:123
bool isConstexprSpecified() const
Definition: DeclSpec.h:706
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void setConstexpr(bool IC)
Definition: Decl.h:1279
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
Definition: SemaDecl.cpp:13455
Expr * getAsmLabel() const
Definition: DeclSpec.h:2210
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase, unsigned AttrSpellingListIndex, MSInheritanceAttr::Spelling SemanticSpelling)
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:107
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old)
checkNewAttributesAfterDef - If we already have a definition, check that there are no new attributes ...
Definition: SemaDecl.cpp:2344
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
Definition: SemaDecl.cpp:7303
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3188
static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl< unsigned > &Params)
hasSimilarParameters - Determine whether the C++ functions Declaration and Definition have "nearly" m...
Definition: SemaDecl.cpp:4684
StorageClass
Storage classes.
Definition: Specifiers.h:201
Expr * getSubExpr() const
Definition: Expr.h:1695
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1774
void AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl, CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
Direct list-initialization (C++11)
Definition: Decl.h:780
bool isFunctionOrMethod() const
Definition: DeclBase.h:1263
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:224
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1214
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1613
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1366
static const TST TST_int
Definition: DeclSpec.h:278
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
bool isExternallyVisible() const
Definition: Decl.h:348
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
Definition: Decl.h:2657
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1114
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition: Type.cpp:47
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
Definition: Sema/Lookup.h:595
struct CXXOpName CXXOperatorName
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
DeclContext * getContainingDC(DeclContext *DC)
Definition: SemaDecl.cpp:1077
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1244
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
TagDecl * getDefinition() const
getDefinition - Returns the TagDecl that actually defines this struct/union/class/enum.
Definition: Decl.cpp:3567
ValueDecl * getDecl()
Definition: Expr.h:1017
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1306
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:339
void setStorageClass(StorageClass SC)
Definition: Decl.cpp:1813
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2461
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1137
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:147
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
SourceLocation getLocEnd() const LLVM_READONLY
Definition: TypeLoc.h:131
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:2957
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1797
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:456
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3372
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:442
static bool shouldConsiderLinkage(const VarDecl *VD)
Definition: SemaDecl.cpp:5768
bool checkInitIsICE() const
Determine whether the value of the initializer attached to this declaration is an integral constant e...
Definition: Decl.cpp:2213
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:165
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
Definition: DeclCXX.h:1247
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:671
bool isVirtualSpecified() const
Definition: DeclSpec.h:567
static void ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD, OverrideErrorKind OEK=OEK_All)
Report an error regarding overriding, along with any relevant overriden methods.
Definition: SemaDecl.cpp:7046
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
Definition: TokenKinds.h:41
decl_range found_decls()
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:231
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:2961
VarDecl * getCanonicalDecl() override
Definition: Decl.cpp:1908
unsigned getEditDistance(bool Normalized=true) const
Gets the "edit distance" of the typo correction from the typo.
unsigned getSpellingListIndex() const
Definition: Attr.h:91
CanQualType SignedCharTy
Definition: ASTContext.h:901
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:553
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1883
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:156
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Basic/Module.h:379
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:94
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
Definition: SemaDecl.cpp:775
param_const_iterator param_end() const
Definition: DeclObjC.h:357
bool isAmbiguous() const
Definition: Sema/Lookup.h:285
static bool checkGlobalOrExternCConflict(Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous)
Check for conflict between this global or extern "C" declaration and previous global or extern "C" de...
Definition: SemaDecl.cpp:6646
static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD)
Tries to perform unqualified lookup of the type decls in bases for dependent class.
Definition: SemaDecl.cpp:146
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:11147
Decl * ActOnSkippedFunctionBody(Decl *Decl)
Definition: SemaDecl.cpp:11429
void DiagnoseUnusedParameters(ArrayRef< ParmVarDecl * > Parameters)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
Definition: SemaDecl.cpp:10929
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
UnqualifiedTypeNameLookupResult
Definition: SemaDecl.cpp:134
NamedDecl * ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S)
ImplicitlyDefineFunction - An undeclared identifier was used in a function call, forming a call to an...
Definition: SemaDecl.cpp:11732
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
Definition: SemaDecl.cpp:5754
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
Definition: DeclSpec.cpp:349
TypeLoc getInnerLoc() const
Definition: TypeLoc.h:1047
void setTypeForDecl(const Type *TD)
Definition: Decl.h:2591
Wrapper for source info for arrays.
Definition: TypeLoc.h:1358
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
Definition: SemaDecl.cpp:3726
bool doesThisDeclarationHaveABody() const
doesThisDeclarationHaveABody - Returns whether this specific declaration of the function has a body -...
Definition: Decl.h:1821
There is no lifetime qualification on this type.
Definition: Type.h:134
ExtInfo withRegParm(unsigned RegParm) const
Definition: Type.h:2980
DeclContext * getEntity() const
Definition: Scope.h:313
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:215
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:2911
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:848
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:236
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:1834
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1579
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Definition: SemaDecl.cpp:11038
The "struct" keyword.
Definition: Type.h:4344
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition: Sema.h:2708
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:145
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
Kind
static bool hasParsedAttr(Scope *S, const AttributeList *AttrList, AttributeList::Kind Kind)
Definition: SemaDecl.cpp:5789
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5730
bool isConst(unsigned ID) const
Return true if this function has no side effects and doesn't read memory.
Definition: Builtins.h:104
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:144
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
Definition: DeclSpec.h:1497
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:3748
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
Definition: SemaDecl.cpp:14749
SourceLocation getOuterLocStart() const
getOuterLocStart - Return SourceLocation representing start of source range taking into account any o...
Definition: Decl.cpp:1695
OverrideErrorKind
Definition: SemaDecl.cpp:7037
ExternCContextDecl * getExternCContextDecl() const
Definition: ASTContext.cpp:905
Encodes a location in the source.
enumerator_range enumerators() const
Definition: Decl.h:3109
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Determines whether this field is a representative for an anonymous struct ...
Definition: Decl.cpp:3458
Sugar for parentheses used when specifying types.
Definition: Type.h:2148
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
bool CheckForConstantInitializer(Expr *e, QualType t)
type checking declaration initializers (C99 6.7.8)
Definition: SemaDecl.cpp:9074
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2742
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceRange BraceRange)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
Definition: SemaDecl.cpp:13178
SourceLocation CurrentPragmaLocation
Definition: Sema.h:387
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3733
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5259
const TemplateArgument * iterator
Definition: Type.h:4233
bool containedInPrototypeScope() const
containedInPrototypeScope - Return true if this or a parent scope is a FunctionPrototypeScope.
Definition: Scope.cpp:98
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3468
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:1650
bool isPredefinedRuntimeFunction(unsigned ID) const
Determines whether this builtin is a predefined compiler-rt/libgcc function, such as "__clear_cache"...
Definition: Builtins.h:145
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition: ScopeInfo.h:669
void setBraceRange(SourceRange R)
Definition: Decl.h:2847
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:895
Expr * getRepAsExpr() const
Definition: DeclSpec.h:495
bool isShadowed() const
Determine whether the lookup result was shadowed by some other declaration that lookup ignored...
Definition: Sema/Lookup.h:443
DLLExportAttr * mergeDLLExportAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1748
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:10491
void AddKnownFunctionAttributes(FunctionDecl *FD)
Adds any function attributes that we know a priori based on the declaration of this function...
Definition: SemaDecl.cpp:11827
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Definition: SemaDecl.cpp:15205
bool isValid() const
Return true if this is a valid SourceLocation object.
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
void setFreeStanding(bool isFreeStanding=true)
Definition: Decl.h:2894
const std::string ID
reference front() const
Definition: DeclBase.h:1109
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1177
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2727
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have...
Definition: Linkage.h:55
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
bool isValid() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ASTContext & getASTContext() const
Definition: Sema.h:1069
bool isLocalVarDecl() const
isLocalVarDecl - Returns true for local variable declarations other than parameters.
Definition: Decl.h:1027
static const TST TST_union
Definition: DeclSpec.h:289
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:93
CommonAttr * mergeCommonAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:424
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error...
Definition: DeclSpec.cpp:502
ParsedType getRepAsType() const
Definition: DeclSpec.h:487
bool isConstWithoutErrno(unsigned ID) const
Return true if this function has no side effects and doesn't read memory, except for possibly errno...
Definition: Builtins.h:184
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
void setDefaulted(bool D=true)
Definition: Decl.h:1854
void setHasFlexibleArrayMember(bool V)
Definition: Decl.h:3306
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used...
Definition: SemaDecl.cpp:11393
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
Definition: SemaType.cpp:6848
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
void addOverriddenMethod(const CXXMethodDecl *MD)
Definition: DeclCXX.cpp:1641
static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, QualType T, SourceLocation NameLoc)
Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
Definition: SemaDecl.cpp:760
void setEntity(DeclContext *E)
Definition: Scope.h:314
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T)
Retrieve a version of the type 'T' that is elaborated by Keyword and qualified by the nested-name-spe...
Definition: SemaType.cpp:7212
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:1989
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:2966
SourceRange getExceptionSpecRange() const
Definition: DeclSpec.h:1356
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1625
SourceLocation getStrTokenLoc(unsigned TokNum) const
Definition: Expr.h:1576
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Sema/Lookup.h:52
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1449
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2171
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:707
bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld)
Completes the merge of two function declarations that are known to be compatible. ...
Definition: SemaDecl.cpp:3263
CanQualType VoidTy
Definition: ASTContext.h:893
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
decl_range decls() const
Definition: Scope.h:270
Describes the kind of initialization being performed, along with location information for tokens rela...
bool hasVolatileMember() const
Definition: Decl.h:3328
arg_range arguments()
Definition: Expr.h:2242
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or NULL if no such declaration exists...
Definition: DeclTemplate.h:925
A class for iterating through a result set and possibly filtering out results.
Definition: Sema/Lookup.h:600
This declaration is only a declaration.
Definition: Decl.h:1069
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:568
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2734
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:545
static const TST TST_typeofType
Definition: DeclSpec.h:294
SourceLocation getBegin() const
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:165
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1407
No entity found met the criteria.
Definition: Sema/Lookup.h:34
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
const IdentifierInfo * getIdentifier() const
Definition: Type.h:4580
bool isFileContext() const
Definition: DeclBase.h:1279
static bool AllowOverloadingOfFunction(LookupResult &Previous, ASTContext &Context)
Determine whether we allow overloading of the function PrevDecl with another declaration.
Definition: SemaDecl.cpp:1231
PtrTy get() const
Definition: Ownership.h:75
SourceRange getSourceRange() const override LLVM_READONLY
Definition: Decl.cpp:1840
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:94
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:2901
void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl< Decl * > &AllIvarDecls)
ActOnLastBitfield - This routine handles synthesized bitfields rules for class and class extensions...
Definition: SemaDecl.cpp:13820
void DiagnoseSizeOfParametersAndReturnValue(ArrayRef< ParmVarDecl * > Parameters, QualType ReturnTy, NamedDecl *D)
Diagnose whether the size of parameters or return value of a function or obj-c method definition is p...
Definition: SemaDecl.cpp:10944
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2687
Expr ** getExprs()
Definition: Expr.h:4362
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2320
bool isStaticMember()
Returns true if this declares a static member.
Definition: DeclSpec.cpp:341
static ImportDecl * CreateImplicit(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, SourceLocation EndLoc)
Create a new module import declaration for an implicitly-generated import.
Definition: Decl.cpp:4253
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2067
static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old)
Definition: SemaDecl.cpp:3321
Assigning into this object requires a lifetime extension.
Definition: Type.h:151
bool hasObjectMember() const
Definition: Decl.h:3325
static bool isExternC(T *D)
Definition: SemaDecl.cpp:2671
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
Definition: SemaDecl.cpp:11087
Attr * clone(ASTContext &C) const
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5329
bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg)
Determine whether this builtin is like scanf in its formatting rules and, if so, set the index to the...
Definition: Builtins.cpp:132
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
Definition: SemaDecl.cpp:13854
void setObjCSuperType(QualType ST)
Definition: ASTContext.h:1383
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:427
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:652
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:542
static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T...
Definition: SemaDecl.cpp:14269
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:262
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
Definition: DeclSpec.h:2237
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S, IdentifierInfo *II)
Looks up the declaration of "struct objc_super" and saves it for later use in building builtin declar...
Definition: SemaDecl.cpp:1748
Opcode getOpcode() const
Definition: Expr.h:1692
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
Definition: SemaDecl.cpp:12053
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:3728
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
bool isFunctionProtoType() const
Definition: Type.h:1662
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1302
QualType getPointeeType() const
Definition: Type.h:2193
void setVirtualAsWritten(bool V)
Definition: Decl.h:1833
A constructor named via a template-id.
Definition: DeclSpec.h:903
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2600
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
C++11 thread_local.
Definition: Specifiers.h:194
bool containsPlaceholderType() const
Definition: DeclSpec.h:520
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
Definition: ASTContext.h:1623
static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext *, ASTContext &)
Determines whether the given declaration is an out-of-scope previous declaration. ...
Definition: SemaDecl.cpp:5442
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1760
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
Definition: DeclSpec.h:2177
AttributeFactory & getFactory() const
CanQualType UnsignedShortTy
Definition: ASTContext.h:902
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1285
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Definition: Type.cpp:112
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
Definition: Builtins.h:93
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, Module *Mod)
Create an implicit import of the given module at the given source location, for error recovery...
Definition: SemaDecl.cpp:15162
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
attr::Kind getKind() const
Definition: Attr.h:87
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2609
QualType getType() const
Definition: Expr.h:126
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3320
CanQualType CharTy
Definition: ASTContext.h:895
TLS with a dynamic initializer.
Definition: Decl.h:787
Represents a template argument.
Definition: TemplateBase.h:40
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
Definition: SemaDecl.cpp:1190
void setBody(Stmt *B)
Definition: Decl.cpp:2501
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2227
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.h:71
TagTypeKind
The kind of a tag type.
Definition: Type.h:4342
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:448
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2328
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:2025
SourceRange getCXXOperatorNameRange() const
getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword)...
static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL)
Definition: SemaDecl.cpp:5222
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:2076
void setHasVolatileMember(bool val)
Definition: Decl.h:3329
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:10916
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5225
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC)
Find the parent class with dependent bases of the innermost enclosing method context.
Definition: SemaDecl.cpp:487
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1135
unsigned getMSCurManglingNumber() const
Definition: Scope.h:303
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1868
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:330
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
Definition: SemaDecl.cpp:1148
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Sema/Lookup.h:257
A template instantiation that is currently in progress.
Definition: Sema.h:6608
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
static const TST TST_decltype
Definition: DeclSpec.h:296
SmallVectorImpl< UniqueVirtualMethod >::iterator overriding_iterator
static const TST TST_auto
Definition: DeclSpec.h:299
bool isFriendSpecified() const
Definition: DeclSpec.h:700
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1209
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W)
DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak applied to it...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion)
We are trying to inject an anonymous member into the given scope; check if there's an existing declar...
Definition: SemaDecl.cpp:4088
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:441
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
OpenCLParamType
Definition: SemaDecl.cpp:7480
bool getProducesResult() const
Definition: Type.h:2946
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool EnumUnderlyingIsImplicit, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
Definition: SemaDecl.cpp:12010
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2521
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1056
void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod)
The parsed has entered a submodule.
Definition: SemaDecl.cpp:15141
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Definition: SemaExpr.cpp:14216
unsigned getNextFunctionPrototypeIndex()
Return the number of parameters declared in this function prototype, increasing it by one for the nex...
Definition: Scope.h:264
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:903
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
Definition: DeclSpec.cpp:1232
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
bool isCallingConv() const
Definition: Type.cpp:3025
const llvm::APSInt & getInitVal() const
Definition: Decl.h:2500
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1454
SectionAttr * mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name, unsigned AttrSpellingListIndex)
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:76
virtual void HandleImplicitImportDecl(ImportDecl *D)
Handle an ImportDecl that was implicitly created due to an inclusion directive.
Definition: ASTConsumer.cpp:29
void setShadowed()
Note that we found and ignored a declaration while performing lookup.
Definition: Sema/Lookup.h:447
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1176
DeclarationName - The name of a declaration.
unsigned short getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
static ObjCIvarDecl::AccessControl TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility)
TranslateIvarVisibility - Translate visibility from a token ID to an AST enum value.
Definition: SemaDecl.cpp:13694
CallingConv getCC() const
Definition: Type.h:2954
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5232
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
Definition: SemaDecl.cpp:3732
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
Expr * getSizeExpr() const
Definition: TypeLoc.h:1381
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:1911
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1113
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
Definition: SemaDecl.cpp:7338
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
A mapping from each virtual member function to its set of final overriders.
StringRef getString() const
Definition: Expr.h:1514
virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0
Attempt to load the given module.
bool isThisDeclarationADefinition() const
isThisDeclarationADefinition - Returns whether this specific declaration of the function is also a de...
Definition: Decl.h:1814
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:693
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
size_t param_size() const
Definition: Decl.h:2004
EnumDecl - Represents an enum.
Definition: Decl.h:3013
VisibilityAttr * mergeVisibilityAttr(Decl *D, SourceRange Range, VisibilityAttr::VisibilityType Vis, unsigned AttrSpellingListIndex)
void setInlineSpecified()
Definition: Decl.h:1265
detail::InMemoryDirectory::const_iterator E
void mergeNRVOIntoParent()
Definition: Scope.cpp:122
QualType getModifiedType() const
Definition: Type.h:3831
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
Definition: SemaDecl.cpp:710
bool isSimpleTypeSpecifier(tok::TokenKind Kind) const
Determine whether the token kind starts a simple-type-specifier.
Definition: SemaDecl.cpp:95
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
bool isHalfType() const
Definition: Type.h:5686
SourceLocation getNoreturnSpecLoc() const
Definition: DeclSpec.h:574
bool hasName() const
hasName - Whether this declarator has a name, which might be an identifier (accessible via getIdentif...
Definition: DeclSpec.h:1968
bool isSamplerT() const
Definition: Type.h:5603
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2205
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Sema/Lookup.h:292
static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D)
Definition: SemaDecl.cpp:1493
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1966
void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, SourceLocation FinalLoc, bool IsFinalSpelledSealed, SourceLocation LBraceLoc)
ActOnStartCXXMemberDeclarations - Invoked when we have parsed a C++ record definition's base-specifie...
Definition: SemaDecl.cpp:13141
bool isMsStruct(const ASTContext &C) const
isMsStrust - Get whether or not this is an ms_struct which can be turned on with an attribute...
Definition: Decl.cpp:3784
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void setPreviousDeclInSameBlockScope(bool Same)
Definition: Decl.h:1300
DiagList Warnings
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
Definition: Decl.cpp:3627
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
Definition: SemaDecl.cpp:10971
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
static const TST TST_unspecified
Definition: DeclSpec.h:272
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Definition: Decl.cpp:4187
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1473
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D)
Definition: SemaInternal.h:54
const RecordType * getAsStructureType() const
Definition: Type.cpp:431
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
Definition: SemaDecl.cpp:2625
All of the names in this module are visible.
Definition: Basic/Module.h:210
known_extensions_range known_extensions() const
Definition: DeclObjC.h:1663
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2413
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2117
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1807
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated", "unavailable", and "availability").
Definition: Sema.h:2149
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant...
Definition: Expr.cpp:2614
NamedDecl * ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous)
Definition: SemaDecl.cpp:5309
Pointer to a block type.
Definition: Type.h:2286
void RemoveDecl(Decl *D)
Definition: Scope.h:279
Name lookup found a single declaration that met the criteria.
Definition: Sema/Lookup.h:43
bool empty() const
Return true if no decls were found.
Definition: Sema/Lookup.h:323
void setImplicitlyInline()
Definition: Decl.h:1270
static ObjCIvarDecl * Create(ASTContext &C, ObjCContainerDecl *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW=nullptr, bool synthesized=false)
Definition: DeclObjC.cpp:1677
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
bool isKeyword() const
bool isObjCObjectType() const
Definition: Type.h:5557
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2461
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:96
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition: Decl.h:3180
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
SourceManager & getSourceManager() const
Definition: Sema.h:1067
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3590
CanQualType UnknownAnyTy
Definition: ASTContext.h:909
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
Definition: SemaDecl.cpp:13222
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
Definition: SemaDecl.cpp:1568
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
QualType getCanonicalType() const
Definition: Type.h:5298
ValueType CurrentValue
Definition: Sema.h:386
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2177
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
Definition: DeclSpec.h:1208
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:151
CanQualType UnsignedLongTy
Definition: ASTContext.h:902
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1649
bool isRedeclaration() const
Definition: DeclSpec.h:2263
bool isDeduced() const
Definition: Type.h:4114
CanQualType DependentTy
Definition: ASTContext.h:909
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false)
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S'...
Definition: SemaDecl.cpp:1309
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
Definition: SemaDecl.cpp:14308
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope...
Definition: SemaDecl.cpp:1314
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3137
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:676
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
bool isFunctionType() const
Definition: Type.h:5479
static const TST TST_typename
Definition: DeclSpec.h:293
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1288
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1534
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1225
const DeclarationNameLoc & getInfo() const
static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D)
Definition: SemaDecl.cpp:5481
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1848
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
Definition: SemaDecl.cpp:10669
void CheckShadow(Scope *S, VarDecl *D, const LookupResult &R)
Diagnose variable or built-in function shadowing.
Definition: SemaDecl.cpp:6534
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname...
Definition: SemaDecl.cpp:15180
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInline, bool isConstexpr, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1540
void setCXXForRangeDecl(bool FRD)
Definition: Decl.h:1240
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
void ActOnCXXForRangeDecl(Decl *D)
Definition: SemaDecl.cpp:10222
Decl * BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy)
BuildAnonymousStructOrUnion - Handle the declaration of an anonymous structure or union...
Definition: SemaDecl.cpp:4247
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
Definition: Sema/Lookup.h:430
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1296
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
Definition: SemaDecl.cpp:4212
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
void setInherited(bool I)
Definition: Attr.h:142
void setBlockVarCopyInits(VarDecl *VD, Expr *Init)
Set the copy inialization expression of a block var decl.
bool isInlineSpecified() const
Definition: DeclSpec.h:560
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs, SourceLocation AttrEnd)
Definition: SemaDecl.cpp:10265
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target, in bits.
The "class" keyword.
Definition: Type.h:4350
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of 'signed long long' and 'unsigned long long' for this targ...
A template-id, e.g., f<int>.
Definition: DeclSpec.h:907
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
DeclResult ActOnModuleImport(SourceLocation AtLoc, SourceLocation ImportLoc, ModuleIdPath Path)
The parser has processed a module import declaration.
Definition: SemaDecl.cpp:15064
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1058
Represents a base class of a C++ class.
Definition: DeclCXX.h:159
CXXScopeSpec & getTypeSpecScope()
Definition: DeclSpec.h:499
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2533
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
static void checkModuleImportContext(Sema &S, Module *M, SourceLocation ImportLoc, DeclContext *DC, bool FromInclude=false)
Definition: SemaDecl.cpp:15026
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
bool isUsable() const
Definition: Ownership.h:161
This is a scope that can contain a declaration.
Definition: Scope.h:58
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:147
SourceManager & getSourceManager()
Definition: ASTContext.h:561
void * SkippedDefinitionContext
Definition: Sema.h:2025
bool isTLSSupported() const
Whether the target supports thread-local storage.
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1972
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:691
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
Definition: SemaDecl.cpp:4916
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:3299
void setPromotionType(QualType T)
Set the promotion type.
Definition: Decl.h:3132
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
Definition: SemaDecl.cpp:1687
Expr * getBase() const
Definition: Expr.h:2405
bool isFunctionPrototypeScope() const
isFunctionPrototypeScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:371
const DeclContext * getCurObjCLexicalContext() const
Definition: Sema.h:9582
bool isObjCGCStrong() const
true when Type is objc's strong.
Definition: Type.h:1004
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2221
Reading or writing from this object requires a barrier call.
Definition: Type.h:148
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
Definition: SemaDecl.cpp:9424
static bool isClassCompatTagKind(TagTypeKind Tag)
Determine if tag kind is a class-key compatible with class for redeclaration (class, struct, or __interface).
Definition: SemaDecl.cpp:12066
llvm::DenseMap< NamedDecl *, NamedDecl * > VisibleNamespaceCache
Map from the most recent declaration of a namespace to the most recent visible declaration of that na...
Definition: Sema.h:6750
static bool isMainFileLoc(const Sema &S, SourceLocation Loc)
Definition: SemaDecl.cpp:1413
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
getCXXLiteralOperatorName - Get the name of the literal operator function with II as the identifier...
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:3761
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
bool hasAddressSpace() const
Definition: Type.h:333
Call-style initialization (C++98)
Definition: Decl.h:779
AttributePool & getPool() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
bool Failed() const
Determine whether the initialization sequence is invalid.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2315
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:188
Describes the sequence of initializations required to initialize a given object or reference with a s...
static QualType TryToFixInvalidVariablyModifiedType(QualType T, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized)
Helper method to turn variable array types into constant array types in certain situations which woul...
Definition: SemaDecl.cpp:5154
static DeclContext * getTagInjectionContext(DeclContext *DC)
Find the DeclContext in which a tag is implicitly declared if we see an elaborated type specifier in ...
Definition: SemaDecl.cpp:12231
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
bool isExplicitSpecified() const
Definition: DeclSpec.h:570
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:1978
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum...
Definition: Decl.h:3163
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or NULL if there isn't one...
ShadowedDeclKind
Enum describing the select options in diag::warn_decl_shadow.
Definition: SemaDecl.cpp:6515
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
BoundNodesTreeBuilder *const Builder
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
Definition: Decl.cpp:4108
static bool isCompoundAssignmentOp(Opcode Opc)
Definition: Expr.h:3027
static const TSCS TSCS_thread_local
Definition: DeclSpec.h:248
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition: Decl.h:952
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:899
static void RemoveUsingDecls(LookupResult &R)
Removes using shadow declarations from the lookup results.
Definition: SemaDecl.cpp:1357
void MergeVarDecl(VarDecl *New, LookupResult &Previous)
MergeVarDecl - We just parsed a variable 'New' which has the same name and scope as a previous declar...
Definition: SemaDecl.cpp:3468
bool isObjCObjectPointerType() const
Definition: Type.h:5554
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2281
Represents a C array with an unspecified size.
Definition: Type.h:2562
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
NeedsRebuildingInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in th...
Definition: SemaDecl.cpp:4719
ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth, bool *ZeroWidth=nullptr)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width...
Definition: SemaDecl.cpp:13241
Missing a type from <stdio.h>
Definition: ASTContext.h:1758
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
Look up a friend of a local class.
Definition: Sema.h:2737
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member...
Definition: Decl.cpp:2065
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3240
void setConstexpr(bool IC)
Definition: Decl.h:1884
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
Definition: SemaDecl.cpp:2713
The parameter type of a method or function.
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1849
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4129
CallingConv getDefaultCallingConvention(bool isVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
bool duplicatesAllowed() const
By default, attributes cannot be duplicated when being merged; however, an attribute can override thi...
Definition: Attr.h:119
Capturing by reference.
Definition: Lambda.h:38
TypeLoc getElementLoc() const
Definition: TypeLoc.h:1388
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition: Scope.h:326
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1258
bool isPipeType() const
Definition: Type.h:5634
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1031
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:461
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:311
The "enum" keyword.
Definition: Type.h:4352
bool isEventT() const
Definition: Type.h:5607
void ActOnPopScope(SourceLocation Loc, Scope *S)
Scope actions.
Definition: SemaDecl.cpp:1633
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Declaration of a class template.
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
Definition: DeclBase.cpp:891
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1276
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
static StorageClass StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS)
StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to a VarDecl::StorageClass.
Definition: SemaDecl.cpp:4191
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
This class is used for builtin types like 'int'.
Definition: Type.h:2039
void addVLATypeCapture(SourceLocation Loc, QualType CaptureType)
Definition: ScopeInfo.h:546
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:353
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
LookupResultKind getResultKind() const
Definition: Sema/Lookup.h:305
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:70
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target...
bool isTypeSpecOwned() const
Definition: DeclSpec.h:483
bool isArrayType() const
Definition: Type.h:5521
decl_iterator end()
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:955
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1466
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2148
Expr * getRHS() const
Definition: Expr.h:2945
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1330
TLS with a known-constant initializer.
Definition: Decl.h:786
SourceRange getSourceRange() const override LLVM_READONLY
Definition: Decl.cpp:3346
AvailabilityResult getCurContextAvailability() const
Definition: SemaDecl.cpp:15242
ExprResult ExprError()
Definition: Ownership.h:268
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:3072
The translation unit is a complete translation unit.
Definition: LangOptions.h:174
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
static TagDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:3002
bool getHasRegParm() const
Definition: Type.h:2947
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
Definition: ASTContext.h:1446
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
Definition: SemaDecl.cpp:2108
bool isIncompleteArrayType() const
Definition: Type.h:5527
CanQualType IntTy
Definition: ASTContext.h:901
bool isRecord() const
Definition: DeclBase.h:1287
static OpaquePtr make(QualTypeP)
Definition: Ownership.h:55
static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New)
Check whether a redeclaration of an entity introduced by a using-declaration is valid, given that we know it's not an overload (nor a hidden tag declaration).
Definition: SemaDecl.cpp:2678
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:166
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:80
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:133
static const TST TST_atomic
Definition: DeclSpec.h:302
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
QualType getElementType() const
Definition: Type.h:2490
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
Definition: SemaDecl.cpp:5284
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:991
void ActOnObjCContainerFinishDefinition()
Definition: SemaDecl.cpp:13206
SourceManager & SourceMgr
Definition: Sema.h:302
bool isResolvedMSAsmLabel() const
Definition: Decl.h:460
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
static const TST TST_struct
Definition: DeclSpec.h:290
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:52
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, Expr *Cpy)
Definition: ScopeInfo.h:538
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3308
SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD)
Invoked when we enter a tag definition that we're skipping.
Definition: SemaDecl.cpp:1127
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
Definition: TypeLoc.h:173
static bool hasDependentAlignment(VarDecl *VD)
Determines if a variable's alignment is dependent.
Definition: SemaDecl.cpp:10479
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Sema/Lookup.h:566
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2008
void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod)
The parser has left a submodule.
Definition: SemaDecl.cpp:15149
AttributeList * getNext() const
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2631
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:80
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:109
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1034
A trivial tuple used to represent a source range.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition: TypeLoc.h:297
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
Definition: Decl.h:3149
ASTContext & Context
Definition: Sema.h:299
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
FunctionDecl * getCanonicalDecl() override
Definition: Decl.cpp:2676
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:988
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1746
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
Definition: ASTContext.h:1520
bool isInvalidType() const
Definition: DeclSpec.h:2222
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
Definition: ASTContext.h:1498
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:703
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:2654
CanQualType BoolTy
Definition: ASTContext.h:894
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2607
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
No keyword precedes the qualified type name.
Definition: Type.h:4372
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D)
Check for this common pattern:
Definition: SemaDecl.cpp:1373
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5318
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition: Decl.h:1864
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
Definition: SemaDecl.cpp:5531
SourceLocation EndLocation
The location of the last token that describes this unqualified-id.
Definition: DeclSpec.h:961
ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg)
Attempt to behave like MSVC in situations where lookup of an unqualified type name has failed in a de...
Definition: SemaDecl.cpp:497
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
Definition: SemaDecl.cpp:3431
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2644
LambdaCaptureDefault getLambdaCaptureDefault() const
Definition: DeclCXX.h:1052
virtual void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc)=0
Make the given module visible.
Describes an entity that is being initialized.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:3443
unsigned NumArgs
NumArgs - The number of template arguments.
Decl * getObjCDeclContext() const
Definition: SemaDecl.cpp:15238
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
Definition: DeclSpec.h:2250
NamedDecl * Previous
Definition: Sema.h:1507
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:608
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
Definition: SemaDecl.cpp:3299
Missing a type from <setjmp.h>
Definition: ASTContext.h:1759
void setType(QualType newType)
Definition: Decl.h:600
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isExplicit, bool isInline, bool isImplicitlyDeclared, bool isConstexpr, InheritedConstructor Inherited=InheritedConstructor())
Definition: DeclCXX.cpp:1833
Wrapper for source info for pointers.
Definition: TypeLoc.h:1134
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3480
ParsedAttributes - A collection of parsed attributes.
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:1911
static bool isAttributeTargetADefinition(Decl *D)
Definition: SemaDecl.cpp:2127
TemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon, QualType Aliased)
No in-class initializer.
Definition: Specifiers.h:225
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
Definition: SemaDecl.cpp:4561
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:2882
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, unsigned AttrSpellingListIndex)
Attribute merging methods. Return true if a new attribute was added.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
enum clang::UnqualifiedId::IdKind Kind
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
Definition: DeclTemplate.h:838
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
Definition: Sema.h:946
iterator - Iterate over the decls of a specified declaration name.
void clear()
Clears out any current state.
Definition: Sema/Lookup.h:538
A class which abstracts out some details necessary for making a call.
Definition: Type.h:2904
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1286
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1730
Attr - This represents one attribute.
Definition: Attr.h:45
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:749
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2835
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:963
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this method is...
Definition: Decl.h:2455
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2626
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2295
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1729
Decl * ActOnDeclarator(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:4788
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:94
CanQualType UnsignedIntTy
Definition: ASTContext.h:902
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
Definition: SemaDecl.cpp:7519
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5286
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope...
Definition: SemaDecl.cpp:1331
bool isPointerType() const
Definition: Type.h:5482
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:714
bool isPOD() const
Whether this class is a POD-type (C++ [class]p4)
Definition: DeclCXX.h:1135
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
A RAII object to temporarily push a declaration context.
Definition: Sema.h:634
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
Definition: SemaDecl.cpp:1580
bool hasInit() const
Definition: Decl.cpp:2040
The translation unit is a module.
Definition: LangOptions.h:179
const AttributeList * getAttributes() const
Definition: DeclSpec.h:2184
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:131
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.
QualType getDeducedType() const
Get the type deduced for this auto type, or null if it's either not been deduced or was deduced to a ...
Definition: Type.h:4111