clang  3.8.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 using namespace clang;
51 using namespace sema;
52 
54  if (OwnedType) {
55  Decl *Group[2] = { OwnedType, Ptr };
56  return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
57  }
58 
59  return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
60 }
61 
62 namespace {
63 
64 class TypeNameValidatorCCC : public CorrectionCandidateCallback {
65  public:
66  TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false,
67  bool AllowTemplates=false)
68  : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
69  AllowClassTemplates(AllowTemplates) {
70  WantExpressionKeywords = false;
71  WantCXXNamedCasts = false;
72  WantRemainingKeywords = false;
73  }
74 
75  bool ValidateCandidate(const TypoCorrection &candidate) override {
76  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
77  bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
78  bool AllowedTemplate = AllowClassTemplates && isa<ClassTemplateDecl>(ND);
79  return (IsType || AllowedTemplate) &&
80  (AllowInvalidDecl || !ND->isInvalidDecl());
81  }
82  return !WantClassName && candidate.isKeyword();
83  }
84 
85  private:
86  bool AllowInvalidDecl;
87  bool WantClassName;
88  bool AllowClassTemplates;
89 };
90 
91 }
92 
93 /// \brief Determine whether the token kind starts a simple-type-specifier.
95  switch (Kind) {
96  // FIXME: Take into account the current language when deciding whether a
97  // token kind is a valid type specifier
98  case tok::kw_short:
99  case tok::kw_long:
100  case tok::kw___int64:
101  case tok::kw___int128:
102  case tok::kw_signed:
103  case tok::kw_unsigned:
104  case tok::kw_void:
105  case tok::kw_char:
106  case tok::kw_int:
107  case tok::kw_half:
108  case tok::kw_float:
109  case tok::kw_double:
110  case tok::kw_wchar_t:
111  case tok::kw_bool:
112  case tok::kw___underlying_type:
113  case tok::kw___auto_type:
114  return true;
115 
116  case tok::annot_typename:
117  case tok::kw_char16_t:
118  case tok::kw_char32_t:
119  case tok::kw_typeof:
120  case tok::annot_decltype:
121  case tok::kw_decltype:
122  return getLangOpts().CPlusPlus;
123 
124  default:
125  break;
126  }
127 
128  return false;
129 }
130 
131 namespace {
133  NotFound,
134  FoundNonType,
135  FoundType
136 };
137 } // namespace
138 
139 /// \brief Tries to perform unqualified lookup of the type decls in bases for
140 /// dependent class.
141 /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
142 /// type decl, \a FoundType if only type decls are found.
145  SourceLocation NameLoc,
146  const CXXRecordDecl *RD) {
147  if (!RD->hasDefinition())
148  return UnqualifiedTypeNameLookupResult::NotFound;
149  // Look for type decls in base classes.
150  UnqualifiedTypeNameLookupResult FoundTypeDecl =
151  UnqualifiedTypeNameLookupResult::NotFound;
152  for (const auto &Base : RD->bases()) {
153  const CXXRecordDecl *BaseRD = nullptr;
154  if (auto *BaseTT = Base.getType()->getAs<TagType>())
155  BaseRD = BaseTT->getAsCXXRecordDecl();
156  else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
157  // Look for type decls in dependent base classes that have known primary
158  // templates.
159  if (!TST || !TST->isDependentType())
160  continue;
161  auto *TD = TST->getTemplateName().getAsTemplateDecl();
162  if (!TD)
163  continue;
164  auto *BasePrimaryTemplate =
165  dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl());
166  if (!BasePrimaryTemplate)
167  continue;
168  BaseRD = BasePrimaryTemplate;
169  }
170  if (BaseRD) {
171  for (NamedDecl *ND : BaseRD->lookup(&II)) {
172  if (!isa<TypeDecl>(ND))
173  return UnqualifiedTypeNameLookupResult::FoundNonType;
174  FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
175  }
176  if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
177  switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
178  case UnqualifiedTypeNameLookupResult::FoundNonType:
179  return UnqualifiedTypeNameLookupResult::FoundNonType;
180  case UnqualifiedTypeNameLookupResult::FoundType:
181  FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
182  break;
183  case UnqualifiedTypeNameLookupResult::NotFound:
184  break;
185  }
186  }
187  }
188  }
189 
190  return FoundTypeDecl;
191 }
192 
194  const IdentifierInfo &II,
195  SourceLocation NameLoc) {
196  // Lookup in the parent class template context, if any.
197  const CXXRecordDecl *RD = nullptr;
198  UnqualifiedTypeNameLookupResult FoundTypeDecl =
199  UnqualifiedTypeNameLookupResult::NotFound;
200  for (DeclContext *DC = S.CurContext;
201  DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
202  DC = DC->getParent()) {
203  // Look for type decls in dependent base classes that have known primary
204  // templates.
205  RD = dyn_cast<CXXRecordDecl>(DC);
206  if (RD && RD->getDescribedClassTemplate())
207  FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
208  }
209  if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
210  return ParsedType();
211 
212  // We found some types in dependent base classes. Recover as if the user
213  // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the
214  // lookup during template instantiation.
215  S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II;
216 
218  auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
219  cast<Type>(Context.getRecordType(RD)));
220  QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
221 
222  CXXScopeSpec SS;
223  SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
224 
226  DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
227  DepTL.setNameLoc(NameLoc);
229  DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
230  return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
231 }
232 
233 /// \brief If the identifier refers to a type name within this scope,
234 /// return the declaration of that type.
235 ///
236 /// This routine performs ordinary name lookup of the identifier II
237 /// within the given scope, with optional C++ scope specifier SS, to
238 /// determine whether the name refers to a type. If so, returns an
239 /// opaque pointer (actually a QualType) corresponding to that
240 /// type. Otherwise, returns NULL.
242  Scope *S, CXXScopeSpec *SS,
243  bool isClassName, bool HasTrailingDot,
244  ParsedType ObjectTypePtr,
245  bool IsCtorOrDtorName,
246  bool WantNontrivialTypeSourceInfo,
247  IdentifierInfo **CorrectedII) {
248  // Determine where we will perform name lookup.
249  DeclContext *LookupCtx = nullptr;
250  if (ObjectTypePtr) {
251  QualType ObjectType = ObjectTypePtr.get();
252  if (ObjectType->isRecordType())
253  LookupCtx = computeDeclContext(ObjectType);
254  } else if (SS && SS->isNotEmpty()) {
255  LookupCtx = computeDeclContext(*SS, false);
256 
257  if (!LookupCtx) {
258  if (isDependentScopeSpecifier(*SS)) {
259  // C++ [temp.res]p3:
260  // A qualified-id that refers to a type and in which the
261  // nested-name-specifier depends on a template-parameter (14.6.2)
262  // shall be prefixed by the keyword typename to indicate that the
263  // qualified-id denotes a type, forming an
264  // elaborated-type-specifier (7.1.5.3).
265  //
266  // We therefore do not perform any name lookup if the result would
267  // refer to a member of an unknown specialization.
268  if (!isClassName && !IsCtorOrDtorName)
269  return ParsedType();
270 
271  // We know from the grammar that this name refers to a type,
272  // so build a dependent node to describe the type.
273  if (WantNontrivialTypeSourceInfo)
274  return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
275 
277  QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
278  II, NameLoc);
279  return ParsedType::make(T);
280  }
281 
282  return ParsedType();
283  }
284 
285  if (!LookupCtx->isDependentContext() &&
286  RequireCompleteDeclContext(*SS, LookupCtx))
287  return ParsedType();
288  }
289 
290  // FIXME: LookupNestedNameSpecifierName isn't the right kind of
291  // lookup for class-names.
292  LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
293  LookupOrdinaryName;
294  LookupResult Result(*this, &II, NameLoc, Kind);
295  if (LookupCtx) {
296  // Perform "qualified" name lookup into the declaration context we
297  // computed, which is either the type of the base of a member access
298  // expression or the declaration context associated with a prior
299  // nested-name-specifier.
300  LookupQualifiedName(Result, LookupCtx);
301 
302  if (ObjectTypePtr && Result.empty()) {
303  // C++ [basic.lookup.classref]p3:
304  // If the unqualified-id is ~type-name, the type-name is looked up
305  // in the context of the entire postfix-expression. If the type T of
306  // the object expression is of a class type C, the type-name is also
307  // looked up in the scope of class C. At least one of the lookups shall
308  // find a name that refers to (possibly cv-qualified) T.
309  LookupName(Result, S);
310  }
311  } else {
312  // Perform unqualified name lookup.
313  LookupName(Result, S);
314 
315  // For unqualified lookup in a class template in MSVC mode, look into
316  // dependent base classes where the primary class template is known.
317  if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
318  if (ParsedType TypeInBase =
319  recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
320  return TypeInBase;
321  }
322  }
323 
324  NamedDecl *IIDecl = nullptr;
325  switch (Result.getResultKind()) {
328  if (CorrectedII) {
329  TypoCorrection Correction = CorrectTypo(
330  Result.getLookupNameInfo(), Kind, S, SS,
331  llvm::make_unique<TypeNameValidatorCCC>(true, isClassName),
332  CTK_ErrorRecovery);
333  IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
334  TemplateTy Template;
335  bool MemberOfUnknownSpecialization;
337  TemplateName.setIdentifier(NewII, NameLoc);
338  NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
339  CXXScopeSpec NewSS, *NewSSPtr = SS;
340  if (SS && NNS) {
341  NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
342  NewSSPtr = &NewSS;
343  }
344  if (Correction && (NNS || NewII != &II) &&
345  // Ignore a correction to a template type as the to-be-corrected
346  // identifier is not a template (typo correction for template names
347  // is handled elsewhere).
348  !(getLangOpts().CPlusPlus && NewSSPtr &&
349  isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(),
350  false, Template, MemberOfUnknownSpecialization))) {
351  ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
352  isClassName, HasTrailingDot, ObjectTypePtr,
353  IsCtorOrDtorName,
354  WantNontrivialTypeSourceInfo);
355  if (Ty) {
356  diagnoseTypo(Correction,
357  PDiag(diag::err_unknown_type_or_class_name_suggest)
358  << Result.getLookupName() << isClassName);
359  if (SS && NNS)
360  SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
361  *CorrectedII = NewII;
362  return Ty;
363  }
364  }
365  }
366  // If typo correction failed or was not performed, fall through
369  Result.suppressDiagnostics();
370  return ParsedType();
371 
373  // Recover from type-hiding ambiguities by hiding the type. We'll
374  // do the lookup again when looking for an object, and we can
375  // diagnose the error then. If we don't do this, then the error
376  // about hiding the type will be immediately followed by an error
377  // that only makes sense if the identifier was treated like a type.
379  Result.suppressDiagnostics();
380  return ParsedType();
381  }
382 
383  // Look to see if we have a type anywhere in the list of results.
384  for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
385  Res != ResEnd; ++Res) {
386  if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
387  if (!IIDecl ||
388  (*Res)->getLocation().getRawEncoding() <
389  IIDecl->getLocation().getRawEncoding())
390  IIDecl = *Res;
391  }
392  }
393 
394  if (!IIDecl) {
395  // None of the entities we found is a type, so there is no way
396  // to even assume that the result is a type. In this case, don't
397  // complain about the ambiguity. The parser will either try to
398  // perform this lookup again (e.g., as an object name), which
399  // will produce the ambiguity, or will complain that it expected
400  // a type name.
401  Result.suppressDiagnostics();
402  return ParsedType();
403  }
404 
405  // We found a type within the ambiguous lookup; diagnose the
406  // ambiguity and then return that type. This might be the right
407  // answer, or it might not be, but it suppresses any attempt to
408  // perform the name lookup again.
409  break;
410 
411  case LookupResult::Found:
412  IIDecl = Result.getFoundDecl();
413  break;
414  }
415 
416  assert(IIDecl && "Didn't find decl");
417 
418  QualType T;
419  if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
420  DiagnoseUseOfDecl(IIDecl, NameLoc);
421 
422  T = Context.getTypeDeclType(TD);
423  MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
424 
425  // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
426  // constructor or destructor name (in such a case, the scope specifier
427  // will be attached to the enclosing Expr or Decl node).
428  if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) {
429  if (WantNontrivialTypeSourceInfo) {
430  // Construct a type with type-source information.
432  Builder.pushTypeSpec(T).setNameLoc(NameLoc);
433 
434  T = getElaboratedType(ETK_None, *SS, T);
435  ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
438  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
439  } else {
440  T = getElaboratedType(ETK_None, *SS, T);
441  }
442  }
443  } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
444  (void)DiagnoseUseOfDecl(IDecl, NameLoc);
445  if (!HasTrailingDot)
446  T = Context.getObjCInterfaceType(IDecl);
447  }
448 
449  if (T.isNull()) {
450  // If it's not plausibly a type, suppress diagnostics.
451  Result.suppressDiagnostics();
452  return ParsedType();
453  }
454  return ParsedType::make(T);
455 }
456 
457 // Builds a fake NNS for the given decl context.
458 static NestedNameSpecifier *
460  for (;; DC = DC->getLookupParent()) {
461  DC = DC->getPrimaryContext();
462  auto *ND = dyn_cast<NamespaceDecl>(DC);
463  if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
464  return NestedNameSpecifier::Create(Context, nullptr, ND);
465  else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
466  return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
467  RD->getTypeForDecl());
468  else if (isa<TranslationUnitDecl>(DC))
469  return NestedNameSpecifier::GlobalSpecifier(Context);
470  }
471  llvm_unreachable("something isn't in TU scope?");
472 }
473 
475  SourceLocation NameLoc) {
476  // Accepting an undeclared identifier as a default argument for a template
477  // type parameter is a Microsoft extension.
478  Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
479 
480  // Build a fake DependentNameType that will perform lookup into CurContext at
481  // instantiation time. The name specifier isn't dependent, so template
482  // instantiation won't transform it. It will retry the lookup, however.
483  NestedNameSpecifier *NNS =
486 
487  // Build type location information. We synthesized the qualifier, so we have
488  // to build a fake NestedNameSpecifierLoc.
489  NestedNameSpecifierLocBuilder NNSLocBuilder;
490  NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
491  NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
492 
494  DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
495  DepTL.setNameLoc(NameLoc);
497  DepTL.setQualifierLoc(QualifierLoc);
498  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
499 }
500 
501 /// isTagName() - This method is called *for error recovery purposes only*
502 /// to determine if the specified name is a valid tag name ("struct foo"). If
503 /// so, this returns the TST for the tag corresponding to it (TST_enum,
504 /// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose
505 /// cases in C where the user forgot to specify the tag.
507  // Do a tag name lookup in this scope.
508  LookupResult R(*this, &II, SourceLocation(), LookupTagName);
509  LookupName(R, S, false);
512  if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
513  switch (TD->getTagKind()) {
514  case TTK_Struct: return DeclSpec::TST_struct;
516  case TTK_Union: return DeclSpec::TST_union;
517  case TTK_Class: return DeclSpec::TST_class;
518  case TTK_Enum: return DeclSpec::TST_enum;
519  }
520  }
521 
523 }
524 
525 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
526 /// if a CXXScopeSpec's type is equal to the type of one of the base classes
527 /// then downgrade the missing typename error to a warning.
528 /// This is needed for MSVC compatibility; Example:
529 /// @code
530 /// template<class T> class A {
531 /// public:
532 /// typedef int TYPE;
533 /// };
534 /// template<class T> class B : public A<T> {
535 /// public:
536 /// A<T>::TYPE a; // no typename required because A<T> is a base class.
537 /// };
538 /// @endcode
540  if (CurContext->isRecord()) {
542  return true;
543 
544  const Type *Ty = SS->getScopeRep()->getAsType();
545 
546  CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
547  for (const auto &Base : RD->bases())
548  if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
549  return true;
550  return S->isFunctionPrototypeScope();
551  }
552  return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
553 }
554 
556  SourceLocation IILoc,
557  Scope *S,
558  CXXScopeSpec *SS,
559  ParsedType &SuggestedType,
560  bool AllowClassTemplates) {
561  // We don't have anything to suggest (yet).
562  SuggestedType = ParsedType();
563 
564  // There may have been a typo in the name of the type. Look up typo
565  // results, in case we have something that we can suggest.
566  if (TypoCorrection Corrected =
567  CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS,
568  llvm::make_unique<TypeNameValidatorCCC>(
569  false, false, AllowClassTemplates),
570  CTK_ErrorRecovery)) {
571  if (Corrected.isKeyword()) {
572  // We corrected to a keyword.
573  diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II);
574  II = Corrected.getCorrectionAsIdentifierInfo();
575  } else {
576  // We found a similarly-named type or interface; suggest that.
577  if (!SS || !SS->isSet()) {
578  diagnoseTypo(Corrected,
579  PDiag(diag::err_unknown_typename_suggest) << II);
580  } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
581  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
582  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
583  II->getName().equals(CorrectedStr);
584  diagnoseTypo(Corrected,
585  PDiag(diag::err_unknown_nested_typename_suggest)
586  << II << DC << DroppedSpecifier << SS->getRange());
587  } else {
588  llvm_unreachable("could not have corrected a typo here");
589  }
590 
591  CXXScopeSpec tmpSS;
592  if (Corrected.getCorrectionSpecifier())
593  tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
594  SourceRange(IILoc));
595  SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(),
596  IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false,
597  false, ParsedType(),
598  /*IsCtorOrDtorName=*/false,
599  /*NonTrivialTypeSourceInfo=*/true);
600  }
601  return;
602  }
603 
604  if (getLangOpts().CPlusPlus) {
605  // See if II is a class template that the user forgot to pass arguments to.
607  Name.setIdentifier(II, IILoc);
608  CXXScopeSpec EmptySS;
609  TemplateTy TemplateResult;
610  bool MemberOfUnknownSpecialization;
611  if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
612  Name, ParsedType(), true, TemplateResult,
613  MemberOfUnknownSpecialization) == TNK_Type_template) {
614  TemplateName TplName = TemplateResult.get();
615  Diag(IILoc, diag::err_template_missing_args) << TplName;
616  if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
617  Diag(TplDecl->getLocation(), diag::note_template_decl_here)
618  << TplDecl->getTemplateParameters()->getSourceRange();
619  }
620  return;
621  }
622  }
623 
624  // FIXME: Should we move the logic that tries to recover from a missing tag
625  // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
626 
627  if (!SS || (!SS->isSet() && !SS->isInvalid()))
628  Diag(IILoc, diag::err_unknown_typename) << II;
629  else if (DeclContext *DC = computeDeclContext(*SS, false))
630  Diag(IILoc, diag::err_typename_nested_not_found)
631  << II << DC << SS->getRange();
632  else if (isDependentScopeSpecifier(*SS)) {
633  unsigned DiagID = diag::err_typename_missing;
634  if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
635  DiagID = diag::ext_typename_missing;
636 
637  Diag(SS->getRange().getBegin(), DiagID)
638  << SS->getScopeRep() << II->getName()
639  << SourceRange(SS->getRange().getBegin(), IILoc)
640  << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
641  SuggestedType = ActOnTypenameType(S, SourceLocation(),
642  *SS, *II, IILoc).get();
643  } else {
644  assert(SS && SS->isInvalid() &&
645  "Invalid scope specifier has already been diagnosed");
646  }
647 }
648 
649 /// \brief Determine whether the given result set contains either a type name
650 /// or
651 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
652  bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
653  NextToken.is(tok::less);
654 
655  for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
656  if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
657  return true;
658 
659  if (CheckTemplate && isa<TemplateDecl>(*I))
660  return true;
661  }
662 
663  return false;
664 }
665 
666 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
667  Scope *S, CXXScopeSpec &SS,
669  SourceLocation NameLoc) {
670  LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
671  SemaRef.LookupParsedName(R, S, &SS);
672  if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
673  StringRef FixItTagName;
674  switch (Tag->getTagKind()) {
675  case TTK_Class:
676  FixItTagName = "class ";
677  break;
678 
679  case TTK_Enum:
680  FixItTagName = "enum ";
681  break;
682 
683  case TTK_Struct:
684  FixItTagName = "struct ";
685  break;
686 
687  case TTK_Interface:
688  FixItTagName = "__interface ";
689  break;
690 
691  case TTK_Union:
692  FixItTagName = "union ";
693  break;
694  }
695 
696  StringRef TagName = FixItTagName.drop_back();
697  SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
698  << Name << TagName << SemaRef.getLangOpts().CPlusPlus
699  << FixItHint::CreateInsertion(NameLoc, FixItTagName);
700 
701  for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
702  I != IEnd; ++I)
703  SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
704  << Name << TagName;
705 
706  // Replace lookup results with just the tag decl.
707  Result.clear(Sema::LookupTagName);
708  SemaRef.LookupParsedName(Result, S, &SS);
709  return true;
710  }
711 
712  return false;
713 }
714 
715 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
717  QualType T, SourceLocation NameLoc) {
719 
721  Builder.pushTypeSpec(T).setNameLoc(NameLoc);
722 
723  T = S.getElaboratedType(ETK_None, SS, T);
724  ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
726  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
727  return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
728 }
729 
732  SourceLocation NameLoc, const Token &NextToken,
733  bool IsAddressOfOperand,
734  std::unique_ptr<CorrectionCandidateCallback> CCC) {
735  DeclarationNameInfo NameInfo(Name, NameLoc);
736  ObjCMethodDecl *CurMethod = getCurMethodDecl();
737 
738  if (NextToken.is(tok::coloncolon)) {
739  BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
740  QualType(), false, SS, nullptr, false);
741  }
742 
743  LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
744  LookupParsedName(Result, S, &SS, !CurMethod);
745 
746  // For unqualified lookup in a class template in MSVC mode, look into
747  // dependent base classes where the primary class template is known.
748  if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
749  if (ParsedType TypeInBase =
750  recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
751  return TypeInBase;
752  }
753 
754  // Perform lookup for Objective-C instance variables (including automatically
755  // synthesized instance variables), if we're in an Objective-C method.
756  // FIXME: This lookup really, really needs to be folded in to the normal
757  // unqualified lookup mechanism.
758  if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
759  ExprResult E = LookupInObjCMethod(Result, S, Name, true);
760  if (E.get() || E.isInvalid())
761  return E;
762  }
763 
764  bool SecondTry = false;
765  bool IsFilteredTemplateName = false;
766 
767 Corrected:
768  switch (Result.getResultKind()) {
770  // If an unqualified-id is followed by a '(', then we have a function
771  // call.
772  if (!SS.isSet() && NextToken.is(tok::l_paren)) {
773  // In C++, this is an ADL-only call.
774  // FIXME: Reference?
775  if (getLangOpts().CPlusPlus)
776  return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
777 
778  // C90 6.3.2.2:
779  // If the expression that precedes the parenthesized argument list in a
780  // function call consists solely of an identifier, and if no
781  // declaration is visible for this identifier, the identifier is
782  // implicitly declared exactly as if, in the innermost block containing
783  // the function call, the declaration
784  //
785  // extern int identifier ();
786  //
787  // appeared.
788  //
789  // We also allow this in C99 as an extension.
790  if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
791  Result.addDecl(D);
792  Result.resolveKind();
793  return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
794  }
795  }
796 
797  // In C, we first see whether there is a tag type by the same name, in
798  // which case it's likely that the user just forgot to write "enum",
799  // "struct", or "union".
800  if (!getLangOpts().CPlusPlus && !SecondTry &&
801  isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
802  break;
803  }
804 
805  // Perform typo correction to determine if there is another name that is
806  // close to this name.
807  if (!SecondTry && CCC) {
808  SecondTry = true;
809  if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
810  Result.getLookupKind(), S,
811  &SS, std::move(CCC),
812  CTK_ErrorRecovery)) {
813  unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
814  unsigned QualifiedDiag = diag::err_no_member_suggest;
815 
816  NamedDecl *FirstDecl = Corrected.getFoundDecl();
817  NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
818  if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
819  UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
820  UnqualifiedDiag = diag::err_no_template_suggest;
821  QualifiedDiag = diag::err_no_member_template_suggest;
822  } else if (UnderlyingFirstDecl &&
823  (isa<TypeDecl>(UnderlyingFirstDecl) ||
824  isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
825  isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
826  UnqualifiedDiag = diag::err_unknown_typename_suggest;
827  QualifiedDiag = diag::err_unknown_nested_typename_suggest;
828  }
829 
830  if (SS.isEmpty()) {
831  diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
832  } else {// FIXME: is this even reachable? Test it.
833  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
834  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
835  Name->getName().equals(CorrectedStr);
836  diagnoseTypo(Corrected, PDiag(QualifiedDiag)
837  << Name << computeDeclContext(SS, false)
838  << DroppedSpecifier << SS.getRange());
839  }
840 
841  // Update the name, so that the caller has the new name.
842  Name = Corrected.getCorrectionAsIdentifierInfo();
843 
844  // Typo correction corrected to a keyword.
845  if (Corrected.isKeyword())
846  return Name;
847 
848  // Also update the LookupResult...
849  // FIXME: This should probably go away at some point
850  Result.clear();
851  Result.setLookupName(Corrected.getCorrection());
852  if (FirstDecl)
853  Result.addDecl(FirstDecl);
854 
855  // If we found an Objective-C instance variable, let
856  // LookupInObjCMethod build the appropriate expression to
857  // reference the ivar.
858  // FIXME: This is a gross hack.
859  if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
860  Result.clear();
861  ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
862  return E;
863  }
864 
865  goto Corrected;
866  }
867  }
868 
869  // We failed to correct; just fall through and let the parser deal with it.
870  Result.suppressDiagnostics();
872 
874  // We performed name lookup into the current instantiation, and there were
875  // dependent bases, so we treat this result the same way as any other
876  // dependent nested-name-specifier.
877 
878  // C++ [temp.res]p2:
879  // A name used in a template declaration or definition and that is
880  // dependent on a template-parameter is assumed not to name a type
881  // unless the applicable name lookup finds a type name or the name is
882  // qualified by the keyword typename.
883  //
884  // FIXME: If the next token is '<', we might want to ask the parser to
885  // perform some heroics to see if we actually have a
886  // template-argument-list, which would indicate a missing 'template'
887  // keyword here.
888  return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
889  NameInfo, IsAddressOfOperand,
890  /*TemplateArgs=*/nullptr);
891  }
892 
893  case LookupResult::Found:
896  break;
897 
899  if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
900  hasAnyAcceptableTemplateNames(Result)) {
901  // C++ [temp.local]p3:
902  // A lookup that finds an injected-class-name (10.2) can result in an
903  // ambiguity in certain cases (for example, if it is found in more than
904  // one base class). If all of the injected-class-names that are found
905  // refer to specializations of the same class template, and if the name
906  // is followed by a template-argument-list, the reference refers to the
907  // class template itself and not a specialization thereof, and is not
908  // ambiguous.
909  //
910  // This filtering can make an ambiguous result into an unambiguous one,
911  // so try again after filtering out template names.
912  FilterAcceptableTemplateNames(Result);
913  if (!Result.isAmbiguous()) {
914  IsFilteredTemplateName = true;
915  break;
916  }
917  }
918 
919  // Diagnose the ambiguity and return an error.
920  return NameClassification::Error();
921  }
922 
923  if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
924  (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
925  // C++ [temp.names]p3:
926  // After name lookup (3.4) finds that a name is a template-name or that
927  // an operator-function-id or a literal- operator-id refers to a set of
928  // overloaded functions any member of which is a function template if
929  // this is followed by a <, the < is always taken as the delimiter of a
930  // template-argument-list and never as the less-than operator.
931  if (!IsFilteredTemplateName)
932  FilterAcceptableTemplateNames(Result);
933 
934  if (!Result.empty()) {
935  bool IsFunctionTemplate;
936  bool IsVarTemplate;
937  TemplateName Template;
938  if (Result.end() - Result.begin() > 1) {
939  IsFunctionTemplate = true;
940  Template = Context.getOverloadedTemplateName(Result.begin(),
941  Result.end());
942  } else {
943  TemplateDecl *TD
944  = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
945  IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
946  IsVarTemplate = isa<VarTemplateDecl>(TD);
947 
948  if (SS.isSet() && !SS.isInvalid())
950  /*TemplateKeyword=*/false,
951  TD);
952  else
953  Template = TemplateName(TD);
954  }
955 
956  if (IsFunctionTemplate) {
957  // Function templates always go through overload resolution, at which
958  // point we'll perform the various checks (e.g., accessibility) we need
959  // to based on which function we selected.
960  Result.suppressDiagnostics();
961 
962  return NameClassification::FunctionTemplate(Template);
963  }
964 
965  return IsVarTemplate ? NameClassification::VarTemplate(Template)
966  : NameClassification::TypeTemplate(Template);
967  }
968  }
969 
970  NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
971  if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
972  DiagnoseUseOfDecl(Type, NameLoc);
973  MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
975  if (SS.isNotEmpty())
976  return buildNestedType(*this, SS, T, NameLoc);
977  return ParsedType::make(T);
978  }
979 
980  ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
981  if (!Class) {
982  // FIXME: It's unfortunate that we don't have a Type node for handling this.
983  if (ObjCCompatibleAliasDecl *Alias =
984  dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
985  Class = Alias->getClassInterface();
986  }
987 
988  if (Class) {
989  DiagnoseUseOfDecl(Class, NameLoc);
990 
991  if (NextToken.is(tok::period)) {
992  // Interface. <something> is parsed as a property reference expression.
993  // Just return "unknown" as a fall-through for now.
994  Result.suppressDiagnostics();
996  }
997 
999  return ParsedType::make(T);
1000  }
1001 
1002  // We can have a type template here if we're classifying a template argument.
1003  if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl))
1004  return NameClassification::TypeTemplate(
1005  TemplateName(cast<TemplateDecl>(FirstDecl)));
1006 
1007  // Check for a tag type hidden by a non-type decl in a few cases where it
1008  // seems likely a type is wanted instead of the non-type that was found.
1009  bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star);
1010  if ((NextToken.is(tok::identifier) ||
1011  (NextIsOp &&
1012  FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1013  isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
1014  TypeDecl *Type = Result.getAsSingle<TypeDecl>();
1015  DiagnoseUseOfDecl(Type, NameLoc);
1016  QualType T = Context.getTypeDeclType(Type);
1017  if (SS.isNotEmpty())
1018  return buildNestedType(*this, SS, T, NameLoc);
1019  return ParsedType::make(T);
1020  }
1021 
1022  if (FirstDecl->isCXXClassMember())
1023  return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
1024  nullptr, S);
1025 
1026  bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1027  return BuildDeclarationNameExpr(SS, Result, ADL);
1028 }
1029 
1030 // Determines the context to return to after temporarily entering a
1031 // context. This depends in an unnecessarily complicated way on the
1032 // exact ordering of callbacks from the parser.
1034 
1035  // Functions defined inline within classes aren't parsed until we've
1036  // finished parsing the top-level class, so the top-level class is
1037  // the context we'll need to return to.
1038  // A Lambda call operator whose parent is a class must not be treated
1039  // as an inline member function. A Lambda can be used legally
1040  // either as an in-class member initializer or a default argument. These
1041  // are parsed once the class has been marked complete and so the containing
1042  // context would be the nested class (when the lambda is defined in one);
1043  // If the class is not complete, then the lambda is being used in an
1044  // ill-formed fashion (such as to specify the width of a bit-field, or
1045  // in an array-bound) - in which case we still want to return the
1046  // lexically containing DC (which could be a nested class).
1047  if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) {
1048  DC = DC->getLexicalParent();
1049 
1050  // A function not defined within a class will always return to its
1051  // lexical context.
1052  if (!isa<CXXRecordDecl>(DC))
1053  return DC;
1054 
1055  // A C++ inline method/friend is parsed *after* the topmost class
1056  // it was declared in is fully parsed ("complete"); the topmost
1057  // class is the context we need to return to.
1058  while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
1059  DC = RD;
1060 
1061  // Return the declaration context of the topmost class the inline method is
1062  // declared in.
1063  return DC;
1064  }
1065 
1066  return DC->getLexicalParent();
1067 }
1068 
1070  assert(getContainingDC(DC) == CurContext &&
1071  "The next DeclContext should be lexically contained in the current one.");
1072  CurContext = DC;
1073  S->setEntity(DC);
1074 }
1075 
1077  assert(CurContext && "DeclContext imbalance!");
1078 
1079  CurContext = getContainingDC(CurContext);
1080  assert(CurContext && "Popped translation unit!");
1081 }
1082 
1084  Decl *D) {
1085  // Unlike PushDeclContext, the context to which we return is not necessarily
1086  // the containing DC of TD, because the new context will be some pre-existing
1087  // TagDecl definition instead of a fresh one.
1088  auto Result = static_cast<SkippedDefinitionContext>(CurContext);
1089  CurContext = cast<TagDecl>(D)->getDefinition();
1090  assert(CurContext && "skipping definition of undefined tag");
1091  // Start lookups from the parent of the current context; we don't want to look
1092  // into the pre-existing complete definition.
1093  S->setEntity(CurContext->getLookupParent());
1094  return Result;
1095 }
1096 
1098  CurContext = static_cast<decltype(CurContext)>(Context);
1099 }
1100 
1101 /// EnterDeclaratorContext - Used when we must lookup names in the context
1102 /// of a declarator's nested name specifier.
1103 ///
1105  // C++0x [basic.lookup.unqual]p13:
1106  // A name used in the definition of a static data member of class
1107  // X (after the qualified-id of the static member) is looked up as
1108  // if the name was used in a member function of X.
1109  // C++0x [basic.lookup.unqual]p14:
1110  // If a variable member of a namespace is defined outside of the
1111  // scope of its namespace then any name used in the definition of
1112  // the variable member (after the declarator-id) is looked up as
1113  // if the definition of the variable member occurred in its
1114  // namespace.
1115  // Both of these imply that we should push a scope whose context
1116  // is the semantic context of the declaration. We can't use
1117  // PushDeclContext here because that context is not necessarily
1118  // lexically contained in the current context. Fortunately,
1119  // the containing scope should have the appropriate information.
1120 
1121  assert(!S->getEntity() && "scope already has entity");
1122 
1123 #ifndef NDEBUG
1124  Scope *Ancestor = S->getParent();
1125  while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1126  assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1127 #endif
1128 
1129  CurContext = DC;
1130  S->setEntity(DC);
1131 }
1132 
1134  assert(S->getEntity() == CurContext && "Context imbalance!");
1135 
1136  // Switch back to the lexical context. The safety of this is
1137  // enforced by an assert in EnterDeclaratorContext.
1138  Scope *Ancestor = S->getParent();
1139  while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1140  CurContext = Ancestor->getEntity();
1141 
1142  // We don't need to do anything with the scope, which is going to
1143  // disappear.
1144 }
1145 
1146 
1148  // We assume that the caller has already called
1149  // ActOnReenterTemplateScope so getTemplatedDecl() works.
1150  FunctionDecl *FD = D->getAsFunction();
1151  if (!FD)
1152  return;
1153 
1154  // Same implementation as PushDeclContext, but enters the context
1155  // from the lexical parent, rather than the top-level class.
1156  assert(CurContext == FD->getLexicalParent() &&
1157  "The next DeclContext should be lexically contained in the current one.");
1158  CurContext = FD;
1159  S->setEntity(CurContext);
1160 
1161  for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1162  ParmVarDecl *Param = FD->getParamDecl(P);
1163  // If the parameter has an identifier, then add it to the scope
1164  if (Param->getIdentifier()) {
1165  S->AddDecl(Param);
1166  IdResolver.AddDecl(Param);
1167  }
1168  }
1169 }
1170 
1171 
1173  // Same implementation as PopDeclContext, but returns to the lexical parent,
1174  // rather than the top-level class.
1175  assert(CurContext && "DeclContext imbalance!");
1176  CurContext = CurContext->getLexicalParent();
1177  assert(CurContext && "Popped translation unit!");
1178 }
1179 
1180 
1181 /// \brief Determine whether we allow overloading of the function
1182 /// PrevDecl with another declaration.
1183 ///
1184 /// This routine determines whether overloading is possible, not
1185 /// whether some new function is actually an overload. It will return
1186 /// true in C++ (where we can always provide overloads) or, as an
1187 /// extension, in C when the previous function is already an
1188 /// overloaded function declaration or has the "overloadable"
1189 /// attribute.
1191  ASTContext &Context) {
1192  if (Context.getLangOpts().CPlusPlus)
1193  return true;
1194 
1195  if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1196  return true;
1197 
1198  return (Previous.getResultKind() == LookupResult::Found
1199  && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
1200 }
1201 
1202 /// Add this decl to the scope shadowed decl chains.
1203 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
1204  // Move up the scope chain until we find the nearest enclosing
1205  // non-transparent context. The declaration will be introduced into this
1206  // scope.
1207  while (S->getEntity() && S->getEntity()->isTransparentContext())
1208  S = S->getParent();
1209 
1210  // Add scoped declarations into their context, so that they can be
1211  // found later. Declarations without a context won't be inserted
1212  // into any context.
1213  if (AddToContext)
1214  CurContext->addDecl(D);
1215 
1216  // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1217  // are function-local declarations.
1218  if (getLangOpts().CPlusPlus && D->isOutOfLine() &&
1222  return;
1223 
1224  // Template instantiations should also not be pushed into scope.
1225  if (isa<FunctionDecl>(D) &&
1226  cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1227  return;
1228 
1229  // If this replaces anything in the current scope,
1230  IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1231  IEnd = IdResolver.end();
1232  for (; I != IEnd; ++I) {
1233  if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1234  S->RemoveDecl(*I);
1235  IdResolver.RemoveDecl(*I);
1236 
1237  // Should only need to replace one decl.
1238  break;
1239  }
1240  }
1241 
1242  S->AddDecl(D);
1243 
1244  if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1245  // Implicitly-generated labels may end up getting generated in an order that
1246  // isn't strictly lexical, which breaks name lookup. Be careful to insert
1247  // the label at the appropriate place in the identifier chain.
1248  for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1249  DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
1250  if (IDC == CurContext) {
1251  if (!S->isDeclScope(*I))
1252  continue;
1253  } else if (IDC->Encloses(CurContext))
1254  break;
1255  }
1256 
1257  IdResolver.InsertDeclAfter(I, D);
1258  } else {
1259  IdResolver.AddDecl(D);
1260  }
1261 }
1262 
1264  if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
1265  TUScope->AddDecl(D);
1266 }
1267 
1269  bool AllowInlineNamespace) {
1270  return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1271 }
1272 
1274  DeclContext *TargetDC = DC->getPrimaryContext();
1275  do {
1276  if (DeclContext *ScopeDC = S->getEntity())
1277  if (ScopeDC->getPrimaryContext() == TargetDC)
1278  return S;
1279  } while ((S = S->getParent()));
1280 
1281  return nullptr;
1282 }
1283 
1285  DeclContext*,
1286  ASTContext&);
1287 
1288 /// Filters out lookup results that don't fall within the given scope
1289 /// as determined by isDeclInScope.
1291  bool ConsiderLinkage,
1292  bool AllowInlineNamespace) {
1294  while (F.hasNext()) {
1295  NamedDecl *D = F.next();
1296 
1297  if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1298  continue;
1299 
1300  if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1301  continue;
1302 
1303  F.erase();
1304  }
1305 
1306  F.done();
1307 }
1308 
1309 static bool isUsingDecl(NamedDecl *D) {
1310  return isa<UsingShadowDecl>(D) ||
1311  isa<UnresolvedUsingTypenameDecl>(D) ||
1312  isa<UnresolvedUsingValueDecl>(D);
1313 }
1314 
1315 /// Removes using shadow declarations from the lookup results.
1318  while (F.hasNext())
1319  if (isUsingDecl(F.next()))
1320  F.erase();
1321 
1322  F.done();
1323 }
1324 
1325 /// \brief Check for this common pattern:
1326 /// @code
1327 /// class S {
1328 /// S(const S&); // DO NOT IMPLEMENT
1329 /// void operator=(const S&); // DO NOT IMPLEMENT
1330 /// };
1331 /// @endcode
1333  // FIXME: Should check for private access too but access is set after we get
1334  // the decl here.
1336  return false;
1337 
1338  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1339  return CD->isCopyConstructor();
1340  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1341  return Method->isCopyAssignmentOperator();
1342  return false;
1343 }
1344 
1345 // We need this to handle
1346 //
1347 // typedef struct {
1348 // void *foo() { return 0; }
1349 // } A;
1350 //
1351 // When we see foo we don't know if after the typedef we will get 'A' or '*A'
1352 // for example. If 'A', foo will have external linkage. If we have '*A',
1353 // foo will have no linkage. Since we can't know until we get to the end
1354 // of the typedef, this function finds out if D might have non-external linkage.
1355 // Callers should verify at the end of the TU if it D has external linkage or
1356 // not.
1357 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1358  const DeclContext *DC = D->getDeclContext();
1359  while (!DC->isTranslationUnit()) {
1360  if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1361  if (!RD->hasNameForLinkage())
1362  return true;
1363  }
1364  DC = DC->getParent();
1365  }
1366 
1367  return !D->isExternallyVisible();
1368 }
1369 
1370 // FIXME: This needs to be refactored; some other isInMainFile users want
1371 // these semantics.
1372 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1373  if (S.TUKind != TU_Complete)
1374  return false;
1375  return S.SourceMgr.isInMainFile(Loc);
1376 }
1377 
1379  assert(D);
1380 
1381  if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1382  return false;
1383 
1384  // Ignore all entities declared within templates, and out-of-line definitions
1385  // of members of class templates.
1386  if (D->getDeclContext()->isDependentContext() ||
1388  return false;
1389 
1390  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1391  if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1392  return false;
1393 
1394  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1395  if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1396  return false;
1397  } else {
1398  // 'static inline' functions are defined in headers; don't warn.
1399  if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1400  return false;
1401  }
1402 
1403  if (FD->doesThisDeclarationHaveABody() &&
1405  return false;
1406  } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1407  // Constants and utility variables are defined in headers with internal
1408  // linkage; don't warn. (Unlike functions, there isn't a convenient marker
1409  // like "inline".)
1410  if (!isMainFileLoc(*this, VD->getLocation()))
1411  return false;
1412 
1413  if (Context.DeclMustBeEmitted(VD))
1414  return false;
1415 
1416  if (VD->isStaticDataMember() &&
1417  VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1418  return false;
1419  } else {
1420  return false;
1421  }
1422 
1423  // Only warn for unused decls internal to the translation unit.
1424  // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1425  // for inline functions defined in the main source file, for instance.
1426  return mightHaveNonExternalLinkage(D);
1427 }
1428 
1430  if (!D)
1431  return;
1432 
1433  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1434  const FunctionDecl *First = FD->getFirstDecl();
1435  if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1436  return; // First should already be in the vector.
1437  }
1438 
1439  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1440  const VarDecl *First = VD->getFirstDecl();
1441  if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1442  return; // First should already be in the vector.
1443  }
1444 
1445  if (ShouldWarnIfUnusedFileScopedDecl(D))
1446  UnusedFileScopedDecls.push_back(D);
1447 }
1448 
1449 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
1450  if (D->isInvalidDecl())
1451  return false;
1452 
1453  if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() ||
1454  D->hasAttr<ObjCPreciseLifetimeAttr>())
1455  return false;
1456 
1457  if (isa<LabelDecl>(D))
1458  return true;
1459 
1460  // Except for labels, we only care about unused decls that are local to
1461  // functions.
1462  bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1463  if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1464  // For dependent types, the diagnostic is deferred.
1465  WithinFunction =
1466  WithinFunction || (R->isLocalClass() && !R->isDependentType());
1467  if (!WithinFunction)
1468  return false;
1469 
1470  if (isa<TypedefNameDecl>(D))
1471  return true;
1472 
1473  // White-list anything that isn't a local variable.
1474  if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
1475  return false;
1476 
1477  // Types of valid local variables should be complete, so this should succeed.
1478  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1479 
1480  // White-list anything with an __attribute__((unused)) type.
1481  QualType Ty = VD->getType();
1482 
1483  // Only look at the outermost level of typedef.
1484  if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1485  if (TT->getDecl()->hasAttr<UnusedAttr>())
1486  return false;
1487  }
1488 
1489  // If we failed to complete the type for some reason, or if the type is
1490  // dependent, don't diagnose the variable.
1491  if (Ty->isIncompleteType() || Ty->isDependentType())
1492  return false;
1493 
1494  if (const TagType *TT = Ty->getAs<TagType>()) {
1495  const TagDecl *Tag = TT->getDecl();
1496  if (Tag->hasAttr<UnusedAttr>())
1497  return false;
1498 
1499  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1500  if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1501  return false;
1502 
1503  if (const Expr *Init = VD->getInit()) {
1504  if (const ExprWithCleanups *Cleanups =
1505  dyn_cast<ExprWithCleanups>(Init))
1506  Init = Cleanups->getSubExpr();
1507  const CXXConstructExpr *Construct =
1508  dyn_cast<CXXConstructExpr>(Init);
1509  if (Construct && !Construct->isElidable()) {
1510  CXXConstructorDecl *CD = Construct->getConstructor();
1511  if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>())
1512  return false;
1513  }
1514  }
1515  }
1516  }
1517 
1518  // TODO: __attribute__((unused)) templates?
1519  }
1520 
1521  return true;
1522 }
1523 
1524 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1525  FixItHint &Hint) {
1526  if (isa<LabelDecl>(D)) {
1528  tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true);
1529  if (AfterColon.isInvalid())
1530  return;
1532  getCharRange(D->getLocStart(), AfterColon));
1533  }
1534  return;
1535 }
1536 
1538  if (D->getTypeForDecl()->isDependentType())
1539  return;
1540 
1541  for (auto *TmpD : D->decls()) {
1542  if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1543  DiagnoseUnusedDecl(T);
1544  else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1545  DiagnoseUnusedNestedTypedefs(R);
1546  }
1547 }
1548 
1549 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1550 /// unless they are marked attr(unused).
1552  if (!ShouldDiagnoseUnusedDecl(D))
1553  return;
1554 
1555  if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1556  // typedefs can be referenced later on, so the diagnostics are emitted
1557  // at end-of-translation-unit.
1558  UnusedLocalTypedefNameCandidates.insert(TD);
1559  return;
1560  }
1561 
1562  FixItHint Hint;
1564 
1565  unsigned DiagID;
1566  if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1567  DiagID = diag::warn_unused_exception_param;
1568  else if (isa<LabelDecl>(D))
1569  DiagID = diag::warn_unused_label;
1570  else
1571  DiagID = diag::warn_unused_variable;
1572 
1573  Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
1574 }
1575 
1576 static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1577  // Verify that we have no forward references left. If so, there was a goto
1578  // or address of a label taken, but no definition of it. Label fwd
1579  // definitions are indicated with a null substmt which is also not a resolved
1580  // MS inline assembly label name.
1581  bool Diagnose = false;
1582  if (L->isMSAsmLabel())
1583  Diagnose = !L->isResolvedMSAsmLabel();
1584  else
1585  Diagnose = L->getStmt() == nullptr;
1586  if (Diagnose)
1587  S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1588 }
1589 
1591  S->mergeNRVOIntoParent();
1592 
1593  if (S->decl_empty()) return;
1594  assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
1595  "Scope shouldn't contain decls!");
1596 
1597  for (auto *TmpD : S->decls()) {
1598  assert(TmpD && "This decl didn't get pushed??");
1599 
1600  assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1601  NamedDecl *D = cast<NamedDecl>(TmpD);
1602 
1603  if (!D->getDeclName()) continue;
1604 
1605  // Diagnose unused variables in this scope.
1606  if (!S->hasUnrecoverableErrorOccurred()) {
1607  DiagnoseUnusedDecl(D);
1608  if (const auto *RD = dyn_cast<RecordDecl>(D))
1609  DiagnoseUnusedNestedTypedefs(RD);
1610  }
1611 
1612  // If this was a forward reference to a label, verify it was defined.
1613  if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1614  CheckPoppedLabel(LD, *this);
1615 
1616  // Remove this name from our lexical scope.
1617  IdResolver.RemoveDecl(D);
1618  }
1619 }
1620 
1621 /// \brief Look for an Objective-C class in the translation unit.
1622 ///
1623 /// \param Id The name of the Objective-C class we're looking for. If
1624 /// typo-correction fixes this name, the Id will be updated
1625 /// to the fixed name.
1626 ///
1627 /// \param IdLoc The location of the name in the translation unit.
1628 ///
1629 /// \param DoTypoCorrection If true, this routine will attempt typo correction
1630 /// if there is no class with the given name.
1631 ///
1632 /// \returns The declaration of the named Objective-C class, or NULL if the
1633 /// class could not be found.
1635  SourceLocation IdLoc,
1636  bool DoTypoCorrection) {
1637  // The third "scope" argument is 0 since we aren't enabling lazy built-in
1638  // creation from this context.
1639  NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1640 
1641  if (!IDecl && DoTypoCorrection) {
1642  // Perform typo correction at the given location, but only if we
1643  // find an Objective-C class name.
1644  if (TypoCorrection C = CorrectTypo(
1645  DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr,
1646  llvm::make_unique<DeclFilterCCC<ObjCInterfaceDecl>>(),
1647  CTK_ErrorRecovery)) {
1648  diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1649  IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1650  Id = IDecl->getIdentifier();
1651  }
1652  }
1653  ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1654  // This routine must always return a class definition, if any.
1655  if (Def && Def->getDefinition())
1656  Def = Def->getDefinition();
1657  return Def;
1658 }
1659 
1660 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
1661 /// from S, where a non-field would be declared. This routine copes
1662 /// with the difference between C and C++ scoping rules in structs and
1663 /// unions. For example, the following code is well-formed in C but
1664 /// ill-formed in C++:
1665 /// @code
1666 /// struct S6 {
1667 /// enum { BAR } e;
1668 /// };
1669 ///
1670 /// void test_S6() {
1671 /// struct S6 a;
1672 /// a.e = BAR;
1673 /// }
1674 /// @endcode
1675 /// For the declaration of BAR, this routine will return a different
1676 /// scope. The scope S will be the scope of the unnamed enumeration
1677 /// within S6. In C++, this routine will return the scope associated
1678 /// with S6, because the enumeration's scope is a transparent
1679 /// context but structures can contain non-field names. In C, this
1680 /// routine will return the translation unit scope, since the
1681 /// enumeration's scope is a transparent context and structures cannot
1682 /// contain non-field names.
1684  while (((S->getFlags() & Scope::DeclScope) == 0) ||
1685  (S->getEntity() && S->getEntity()->isTransparentContext()) ||
1686  (S->isClassScope() && !getLangOpts().CPlusPlus))
1687  S = S->getParent();
1688  return S;
1689 }
1690 
1691 /// \brief Looks up the declaration of "struct objc_super" and
1692 /// saves it for later use in building builtin declaration of
1693 /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
1694 /// pre-existing declaration exists no action takes place.
1695 static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
1696  IdentifierInfo *II) {
1697  if (!II->isStr("objc_msgSendSuper"))
1698  return;
1699  ASTContext &Context = ThisSema.Context;
1700 
1701  LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
1703  ThisSema.LookupName(Result, S);
1704  if (Result.getResultKind() == LookupResult::Found)
1705  if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1706  Context.setObjCSuperType(Context.getTagDeclType(TD));
1707 }
1708 
1710  switch (Error) {
1711  case ASTContext::GE_None:
1712  return "";
1714  return "stdio.h";
1716  return "setjmp.h";
1718  return "ucontext.h";
1719  }
1720  llvm_unreachable("unhandled error kind");
1721 }
1722 
1723 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1724 /// file scope. lazily create a decl for it. ForRedeclaration is true
1725 /// if we're creating this built-in in anticipation of redeclaring the
1726 /// built-in.
1728  Scope *S, bool ForRedeclaration,
1729  SourceLocation Loc) {
1730  LookupPredefedObjCSuperType(*this, S, II);
1731 
1733  QualType R = Context.GetBuiltinType(ID, Error);
1734  if (Error) {
1735  if (ForRedeclaration)
1736  Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
1737  << getHeaderName(Error) << Context.BuiltinInfo.getName(ID);
1738  return nullptr;
1739  }
1740 
1741  if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(ID)) {
1742  Diag(Loc, diag::ext_implicit_lib_function_decl)
1743  << Context.BuiltinInfo.getName(ID) << R;
1744  if (Context.BuiltinInfo.getHeaderName(ID) &&
1745  !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc))
1746  Diag(Loc, diag::note_include_header_or_declare)
1748  << Context.BuiltinInfo.getName(ID);
1749  }
1750 
1752  if (getLangOpts().CPlusPlus) {
1753  LinkageSpecDecl *CLinkageDecl =
1754  LinkageSpecDecl::Create(Context, Parent, Loc, Loc,
1755  LinkageSpecDecl::lang_c, false);
1756  CLinkageDecl->setImplicit();
1757  Parent->addDecl(CLinkageDecl);
1758  Parent = CLinkageDecl;
1759  }
1760 
1762  Parent,
1763  Loc, Loc, II, R, /*TInfo=*/nullptr,
1764  SC_Extern,
1765  false,
1766  R->isFunctionProtoType());
1767  New->setImplicit();
1768 
1769  // Create Decl objects for each parameter, adding them to the
1770  // FunctionDecl.
1771  if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
1773  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1774  ParmVarDecl *parm =
1776  nullptr, FT->getParamType(i), /*TInfo=*/nullptr,
1777  SC_None, nullptr);
1778  parm->setScopeInfo(0, i);
1779  Params.push_back(parm);
1780  }
1781  New->setParams(Params);
1782  }
1783 
1784  AddKnownFunctionAttributes(New);
1785  RegisterLocallyScopedExternCDecl(New, S);
1786 
1787  // TUScope is the translation-unit scope to insert this function into.
1788  // FIXME: This is hideous. We need to teach PushOnScopeChains to
1789  // relate Scopes to DeclContexts, and probably eliminate CurContext
1790  // entirely, but we're not there yet.
1791  DeclContext *SavedContext = CurContext;
1792  CurContext = Parent;
1793  PushOnScopeChains(New, TUScope);
1794  CurContext = SavedContext;
1795  return New;
1796 }
1797 
1798 /// Typedef declarations don't have linkage, but they still denote the same
1799 /// entity if their types are the same.
1800 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's
1801 /// isSameEntity.
1805  // This is only interesting when modules are enabled.
1806  if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
1807  return;
1808 
1809  // Empty sets are uninteresting.
1810  if (Previous.empty())
1811  return;
1812 
1813  LookupResult::Filter Filter = Previous.makeFilter();
1814  while (Filter.hasNext()) {
1815  NamedDecl *Old = Filter.next();
1816 
1817  // Non-hidden declarations are never ignored.
1818  if (S.isVisible(Old))
1819  continue;
1820 
1821  // Declarations of the same entity are not ignored, even if they have
1822  // different linkages.
1823  if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
1824  if (S.Context.hasSameType(OldTD->getUnderlyingType(),
1825  Decl->getUnderlyingType()))
1826  continue;
1827 
1828  // If both declarations give a tag declaration a typedef name for linkage
1829  // purposes, then they declare the same entity.
1830  if (S.getLangOpts().CPlusPlus &&
1831  OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) &&
1833  continue;
1834  }
1835 
1836  Filter.erase();
1837  }
1838 
1839  Filter.done();
1840 }
1841 
1843  QualType OldType;
1844  if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
1845  OldType = OldTypedef->getUnderlyingType();
1846  else
1847  OldType = Context.getTypeDeclType(Old);
1848  QualType NewType = New->getUnderlyingType();
1849 
1850  if (NewType->isVariablyModifiedType()) {
1851  // Must not redefine a typedef with a variably-modified type.
1852  int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1853  Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
1854  << Kind << NewType;
1855  if (Old->getLocation().isValid())
1856  Diag(Old->getLocation(), diag::note_previous_definition);
1857  New->setInvalidDecl();
1858  return true;
1859  }
1860 
1861  if (OldType != NewType &&
1862  !OldType->isDependentType() &&
1863  !NewType->isDependentType() &&
1864  !Context.hasSameType(OldType, NewType)) {
1865  int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1866  Diag(New->getLocation(), diag::err_redefinition_different_typedef)
1867  << Kind << NewType << OldType;
1868  if (Old->getLocation().isValid())
1869  Diag(Old->getLocation(), diag::note_previous_definition);
1870  New->setInvalidDecl();
1871  return true;
1872  }
1873  return false;
1874 }
1875 
1876 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
1877 /// same name and scope as a previous declaration 'Old'. Figure out
1878 /// how to resolve this situation, merging decls or emitting
1879 /// diagnostics as appropriate. If there was an error, set New to be invalid.
1880 ///
1882  LookupResult &OldDecls) {
1883  // If the new decl is known invalid already, don't bother doing any
1884  // merging checks.
1885  if (New->isInvalidDecl()) return;
1886 
1887  // Allow multiple definitions for ObjC built-in typedefs.
1888  // FIXME: Verify the underlying types are equivalent!
1889  if (getLangOpts().ObjC1) {
1890  const IdentifierInfo *TypeID = New->getIdentifier();
1891  switch (TypeID->getLength()) {
1892  default: break;
1893  case 2:
1894  {
1895  if (!TypeID->isStr("id"))
1896  break;
1897  QualType T = New->getUnderlyingType();
1898  if (!T->isPointerType())
1899  break;
1900  if (!T->isVoidPointerType()) {
1901  QualType PT = T->getAs<PointerType>()->getPointeeType();
1902  if (!PT->isStructureType())
1903  break;
1904  }
1906  // Install the built-in type for 'id', ignoring the current definition.
1908  return;
1909  }
1910  case 5:
1911  if (!TypeID->isStr("Class"))
1912  break;
1914  // Install the built-in type for 'Class', ignoring the current definition.
1916  return;
1917  case 3:
1918  if (!TypeID->isStr("SEL"))
1919  break;
1921  // Install the built-in type for 'SEL', ignoring the current definition.
1923  return;
1924  }
1925  // Fall through - the typedef name was not a builtin type.
1926  }
1927 
1928  // Verify the old decl was also a type.
1929  TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1930  if (!Old) {
1931  Diag(New->getLocation(), diag::err_redefinition_different_kind)
1932  << New->getDeclName();
1933 
1934  NamedDecl *OldD = OldDecls.getRepresentativeDecl();
1935  if (OldD->getLocation().isValid())
1936  Diag(OldD->getLocation(), diag::note_previous_definition);
1937 
1938  return New->setInvalidDecl();
1939  }
1940 
1941  // If the old declaration is invalid, just give up here.
1942  if (Old->isInvalidDecl())
1943  return New->setInvalidDecl();
1944 
1945  if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
1946  auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
1947  auto *NewTag = New->getAnonDeclWithTypedefName();
1948  NamedDecl *Hidden = nullptr;
1949  if (getLangOpts().CPlusPlus && OldTag && NewTag &&
1950  OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
1951  !hasVisibleDefinition(OldTag, &Hidden)) {
1952  // There is a definition of this tag, but it is not visible. Use it
1953  // instead of our tag.
1954  New->setTypeForDecl(OldTD->getTypeForDecl());
1955  if (OldTD->isModed())
1956  New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
1957  OldTD->getUnderlyingType());
1958  else
1959  New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
1960 
1961  // Make the old tag definition visible.
1962  makeMergedDefinitionVisible(Hidden, NewTag->getLocation());
1963 
1964  // If this was an unscoped enumeration, yank all of its enumerators
1965  // out of the scope.
1966  if (isa<EnumDecl>(NewTag)) {
1967  Scope *EnumScope = getNonFieldDeclScope(S);
1968  for (auto *D : NewTag->decls()) {
1969  auto *ED = cast<EnumConstantDecl>(D);
1970  assert(EnumScope->isDeclScope(ED));
1971  EnumScope->RemoveDecl(ED);
1972  IdResolver.RemoveDecl(ED);
1973  ED->getLexicalDeclContext()->removeDecl(ED);
1974  }
1975  }
1976  }
1977  }
1978 
1979  // If the typedef types are not identical, reject them in all languages and
1980  // with any extensions enabled.
1981  if (isIncompatibleTypedef(Old, New))
1982  return;
1983 
1984  // The types match. Link up the redeclaration chain and merge attributes if
1985  // the old declaration was a typedef.
1986  if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
1987  New->setPreviousDecl(Typedef);
1988  mergeDeclAttributes(New, Old);
1989  }
1990 
1991  if (getLangOpts().MicrosoftExt)
1992  return;
1993 
1994  if (getLangOpts().CPlusPlus) {
1995  // C++ [dcl.typedef]p2:
1996  // In a given non-class scope, a typedef specifier can be used to
1997  // redefine the name of any type declared in that scope to refer
1998  // to the type to which it already refers.
1999  if (!isa<CXXRecordDecl>(CurContext))
2000  return;
2001 
2002  // C++0x [dcl.typedef]p4:
2003  // In a given class scope, a typedef specifier can be used to redefine
2004  // any class-name declared in that scope that is not also a typedef-name
2005  // to refer to the type to which it already refers.
2006  //
2007  // This wording came in via DR424, which was a correction to the
2008  // wording in DR56, which accidentally banned code like:
2009  //
2010  // struct S {
2011  // typedef struct A { } A;
2012  // };
2013  //
2014  // in the C++03 standard. We implement the C++0x semantics, which
2015  // allow the above but disallow
2016  //
2017  // struct S {
2018  // typedef int I;
2019  // typedef int I;
2020  // };
2021  //
2022  // since that was the intent of DR56.
2023  if (!isa<TypedefNameDecl>(Old))
2024  return;
2025 
2026  Diag(New->getLocation(), diag::err_redefinition)
2027  << New->getDeclName();
2028  Diag(Old->getLocation(), diag::note_previous_definition);
2029  return New->setInvalidDecl();
2030  }
2031 
2032  // Modules always permit redefinition of typedefs, as does C11.
2033  if (getLangOpts().Modules || getLangOpts().C11)
2034  return;
2035 
2036  // If we have a redefinition of a typedef in C, emit a warning. This warning
2037  // is normally mapped to an error, but can be controlled with
2038  // -Wtypedef-redefinition. If either the original or the redefinition is
2039  // in a system header, don't emit this for compatibility with GCC.
2040  if (getDiagnostics().getSuppressSystemWarnings() &&
2043  return;
2044 
2045  Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
2046  << New->getDeclName();
2047  Diag(Old->getLocation(), diag::note_previous_definition);
2048 }
2049 
2050 /// DeclhasAttr - returns true if decl Declaration already has the target
2051 /// attribute.
2052 static bool DeclHasAttr(const Decl *D, const Attr *A) {
2053  const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2054  const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2055  for (const auto *i : D->attrs())
2056  if (i->getKind() == A->getKind()) {
2057  if (Ann) {
2058  if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2059  return true;
2060  continue;
2061  }
2062  // FIXME: Don't hardcode this check
2063  if (OA && isa<OwnershipAttr>(i))
2064  return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2065  return true;
2066  }
2067 
2068  return false;
2069 }
2070 
2072  if (VarDecl *VD = dyn_cast<VarDecl>(D))
2073  return VD->isThisDeclarationADefinition();
2074  if (TagDecl *TD = dyn_cast<TagDecl>(D))
2075  return TD->isCompleteDefinition() || TD->isBeingDefined();
2076  return true;
2077 }
2078 
2079 /// Merge alignment attributes from \p Old to \p New, taking into account the
2080 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2081 ///
2082 /// \return \c true if any attributes were added to \p New.
2083 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2084  // Look for alignas attributes on Old, and pick out whichever attribute
2085  // specifies the strictest alignment requirement.
2086  AlignedAttr *OldAlignasAttr = nullptr;
2087  AlignedAttr *OldStrictestAlignAttr = nullptr;
2088  unsigned OldAlign = 0;
2089  for (auto *I : Old->specific_attrs<AlignedAttr>()) {
2090  // FIXME: We have no way of representing inherited dependent alignments
2091  // in a case like:
2092  // template<int A, int B> struct alignas(A) X;
2093  // template<int A, int B> struct alignas(B) X {};
2094  // For now, we just ignore any alignas attributes which are not on the
2095  // definition in such a case.
2096  if (I->isAlignmentDependent())
2097  return false;
2098 
2099  if (I->isAlignas())
2100  OldAlignasAttr = I;
2101 
2102  unsigned Align = I->getAlignment(S.Context);
2103  if (Align > OldAlign) {
2104  OldAlign = Align;
2105  OldStrictestAlignAttr = I;
2106  }
2107  }
2108 
2109  // Look for alignas attributes on New.
2110  AlignedAttr *NewAlignasAttr = nullptr;
2111  unsigned NewAlign = 0;
2112  for (auto *I : New->specific_attrs<AlignedAttr>()) {
2113  if (I->isAlignmentDependent())
2114  return false;
2115 
2116  if (I->isAlignas())
2117  NewAlignasAttr = I;
2118 
2119  unsigned Align = I->getAlignment(S.Context);
2120  if (Align > NewAlign)
2121  NewAlign = Align;
2122  }
2123 
2124  if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2125  // Both declarations have 'alignas' attributes. We require them to match.
2126  // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2127  // fall short. (If two declarations both have alignas, they must both match
2128  // every definition, and so must match each other if there is a definition.)
2129 
2130  // If either declaration only contains 'alignas(0)' specifiers, then it
2131  // specifies the natural alignment for the type.
2132  if (OldAlign == 0 || NewAlign == 0) {
2133  QualType Ty;
2134  if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2135  Ty = VD->getType();
2136  else
2137  Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2138 
2139  if (OldAlign == 0)
2140  OldAlign = S.Context.getTypeAlign(Ty);
2141  if (NewAlign == 0)
2142  NewAlign = S.Context.getTypeAlign(Ty);
2143  }
2144 
2145  if (OldAlign != NewAlign) {
2146  S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2147  << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2148  << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2149  S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2150  }
2151  }
2152 
2153  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2154  // C++11 [dcl.align]p6:
2155  // if any declaration of an entity has an alignment-specifier,
2156  // every defining declaration of that entity shall specify an
2157  // equivalent alignment.
2158  // C11 6.7.5/7:
2159  // If the definition of an object does not have an alignment
2160  // specifier, any other declaration of that object shall also
2161  // have no alignment specifier.
2162  S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2163  << OldAlignasAttr;
2164  S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2165  << OldAlignasAttr;
2166  }
2167 
2168  bool AnyAdded = false;
2169 
2170  // Ensure we have an attribute representing the strictest alignment.
2171  if (OldAlign > NewAlign) {
2172  AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2173  Clone->setInherited(true);
2174  New->addAttr(Clone);
2175  AnyAdded = true;
2176  }
2177 
2178  // Ensure we have an alignas attribute if the old declaration had one.
2179  if (OldAlignasAttr && !NewAlignasAttr &&
2180  !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2181  AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2182  Clone->setInherited(true);
2183  New->addAttr(Clone);
2184  AnyAdded = true;
2185  }
2186 
2187  return AnyAdded;
2188 }
2189 
2191  const InheritableAttr *Attr,
2193  InheritableAttr *NewAttr = nullptr;
2194  unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
2195  if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2196  NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2197  AA->getIntroduced(), AA->getDeprecated(),
2198  AA->getObsoleted(), AA->getUnavailable(),
2199  AA->getMessage(), AMK,
2200  AttrSpellingListIndex);
2201  else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2202  NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2203  AttrSpellingListIndex);
2204  else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2205  NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2206  AttrSpellingListIndex);
2207  else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2208  NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2209  AttrSpellingListIndex);
2210  else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2211  NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2212  AttrSpellingListIndex);
2213  else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2214  NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2215  FA->getFormatIdx(), FA->getFirstArg(),
2216  AttrSpellingListIndex);
2217  else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2218  NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2219  AttrSpellingListIndex);
2220  else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2221  NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2222  AttrSpellingListIndex,
2223  IA->getSemanticSpelling());
2224  else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
2225  NewAttr = S.mergeAlwaysInlineAttr(D, AA->getRange(),
2226  &S.Context.Idents.get(AA->getSpelling()),
2227  AttrSpellingListIndex);
2228  else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2229  NewAttr = S.mergeMinSizeAttr(D, MA->getRange(), AttrSpellingListIndex);
2230  else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2231  NewAttr = S.mergeOptimizeNoneAttr(D, OA->getRange(), AttrSpellingListIndex);
2232  else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr))
2233  NewAttr = S.mergeInternalLinkageAttr(
2234  D, InternalLinkageA->getRange(),
2235  &S.Context.Idents.get(InternalLinkageA->getSpelling()),
2236  AttrSpellingListIndex);
2237  else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr))
2238  NewAttr = S.mergeCommonAttr(D, CommonA->getRange(),
2239  &S.Context.Idents.get(CommonA->getSpelling()),
2240  AttrSpellingListIndex);
2241  else if (isa<AlignedAttr>(Attr))
2242  // AlignedAttrs are handled separately, because we need to handle all
2243  // such attributes on a declaration at the same time.
2244  NewAttr = nullptr;
2245  else if ((isa<DeprecatedAttr>(Attr) || isa<UnavailableAttr>(Attr)) &&
2246  (AMK == Sema::AMK_Override ||
2248  NewAttr = nullptr;
2249  else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr))
2250  NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2251 
2252  if (NewAttr) {
2253  NewAttr->setInherited(true);
2254  D->addAttr(NewAttr);
2255  return true;
2256  }
2257 
2258  return false;
2259 }
2260 
2261 static const Decl *getDefinition(const Decl *D) {
2262  if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2263  return TD->getDefinition();
2264  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2265  const VarDecl *Def = VD->getDefinition();
2266  if (Def)
2267  return Def;
2268  return VD->getActingDefinition();
2269  }
2270  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2271  const FunctionDecl* Def;
2272  if (FD->isDefined(Def))
2273  return Def;
2274  }
2275  return nullptr;
2276 }
2277 
2278 static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2279  for (const auto *Attribute : D->attrs())
2280  if (Attribute->getKind() == Kind)
2281  return true;
2282  return false;
2283 }
2284 
2285 /// checkNewAttributesAfterDef - If we already have a definition, check that
2286 /// there are no new attributes in this declaration.
2287 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2288  if (!New->hasAttrs())
2289  return;
2290 
2291  const Decl *Def = getDefinition(Old);
2292  if (!Def || Def == New)
2293  return;
2294 
2295  AttrVec &NewAttributes = New->getAttrs();
2296  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2297  const Attr *NewAttribute = NewAttributes[I];
2298 
2299  if (isa<AliasAttr>(NewAttribute)) {
2300  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
2301  Sema::SkipBodyInfo SkipBody;
2302  S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
2303 
2304  // If we're skipping this definition, drop the "alias" attribute.
2305  if (SkipBody.ShouldSkip) {
2306  NewAttributes.erase(NewAttributes.begin() + I);
2307  --E;
2308  continue;
2309  }
2310  } else {
2311  VarDecl *VD = cast<VarDecl>(New);
2312  unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2314  ? diag::err_alias_after_tentative
2315  : diag::err_redefinition;
2316  S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2317  S.Diag(Def->getLocation(), diag::note_previous_definition);
2318  VD->setInvalidDecl();
2319  }
2320  ++I;
2321  continue;
2322  }
2323 
2324  if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2325  // Tentative definitions are only interesting for the alias check above.
2326  if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2327  ++I;
2328  continue;
2329  }
2330  }
2331 
2332  if (hasAttribute(Def, NewAttribute->getKind())) {
2333  ++I;
2334  continue; // regular attr merging will take care of validating this.
2335  }
2336 
2337  if (isa<C11NoReturnAttr>(NewAttribute)) {
2338  // C's _Noreturn is allowed to be added to a function after it is defined.
2339  ++I;
2340  continue;
2341  } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2342  if (AA->isAlignas()) {
2343  // C++11 [dcl.align]p6:
2344  // if any declaration of an entity has an alignment-specifier,
2345  // every defining declaration of that entity shall specify an
2346  // equivalent alignment.
2347  // C11 6.7.5/7:
2348  // If the definition of an object does not have an alignment
2349  // specifier, any other declaration of that object shall also
2350  // have no alignment specifier.
2351  S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2352  << AA;
2353  S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2354  << AA;
2355  NewAttributes.erase(NewAttributes.begin() + I);
2356  --E;
2357  continue;
2358  }
2359  }
2360 
2361  S.Diag(NewAttribute->getLocation(),
2362  diag::warn_attribute_precede_definition);
2363  S.Diag(Def->getLocation(), diag::note_previous_definition);
2364  NewAttributes.erase(NewAttributes.begin() + I);
2365  --E;
2366  }
2367 }
2368 
2369 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2371  AvailabilityMergeKind AMK) {
2372  if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2373  UsedAttr *NewAttr = OldAttr->clone(Context);
2374  NewAttr->setInherited(true);
2375  New->addAttr(NewAttr);
2376  }
2377 
2378  if (!Old->hasAttrs() && !New->hasAttrs())
2379  return;
2380 
2381  // Attributes declared post-definition are currently ignored.
2382  checkNewAttributesAfterDef(*this, New, Old);
2383 
2384  if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) {
2385  if (AsmLabelAttr *OldA = Old->getAttr<AsmLabelAttr>()) {
2386  if (OldA->getLabel() != NewA->getLabel()) {
2387  // This redeclaration changes __asm__ label.
2388  Diag(New->getLocation(), diag::err_different_asm_label);
2389  Diag(OldA->getLocation(), diag::note_previous_declaration);
2390  }
2391  } else if (Old->isUsed()) {
2392  // This redeclaration adds an __asm__ label to a declaration that has
2393  // already been ODR-used.
2394  Diag(New->getLocation(), diag::err_late_asm_label_name)
2395  << isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange();
2396  }
2397  }
2398 
2399  if (!Old->hasAttrs())
2400  return;
2401 
2402  bool foundAny = New->hasAttrs();
2403 
2404  // Ensure that any moving of objects within the allocated map is done before
2405  // we process them.
2406  if (!foundAny) New->setAttrs(AttrVec());
2407 
2408  for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2409  // Ignore deprecated/unavailable/availability attributes if requested.
2410  AvailabilityMergeKind LocalAMK = AMK_None;
2411  if (isa<DeprecatedAttr>(I) ||
2412  isa<UnavailableAttr>(I) ||
2413  isa<AvailabilityAttr>(I)) {
2414  switch (AMK) {
2415  case AMK_None:
2416  continue;
2417 
2418  case AMK_Redeclaration:
2419  case AMK_Override:
2420  case AMK_ProtocolImplementation:
2421  LocalAMK = AMK;
2422  break;
2423  }
2424  }
2425 
2426  // Already handled.
2427  if (isa<UsedAttr>(I))
2428  continue;
2429 
2430  if (mergeDeclAttribute(*this, New, I, LocalAMK))
2431  foundAny = true;
2432  }
2433 
2434  if (mergeAlignedAttrs(*this, New, Old))
2435  foundAny = true;
2436 
2437  if (!foundAny) New->dropAttrs();
2438 }
2439 
2440 /// mergeParamDeclAttributes - Copy attributes from the old parameter
2441 /// to the new one.
2443  const ParmVarDecl *oldDecl,
2444  Sema &S) {
2445  // C++11 [dcl.attr.depend]p2:
2446  // The first declaration of a function shall specify the
2447  // carries_dependency attribute for its declarator-id if any declaration
2448  // of the function specifies the carries_dependency attribute.
2449  const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2450  if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2451  S.Diag(CDA->getLocation(),
2452  diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2453  // Find the first declaration of the parameter.
2454  // FIXME: Should we build redeclaration chains for function parameters?
2455  const FunctionDecl *FirstFD =
2456  cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2457  const ParmVarDecl *FirstVD =
2458  FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2459  S.Diag(FirstVD->getLocation(),
2460  diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2461  }
2462 
2463  if (!oldDecl->hasAttrs())
2464  return;
2465 
2466  bool foundAny = newDecl->hasAttrs();
2467 
2468  // Ensure that any moving of objects within the allocated map is
2469  // done before we process them.
2470  if (!foundAny) newDecl->setAttrs(AttrVec());
2471 
2472  for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2473  if (!DeclHasAttr(newDecl, I)) {
2474  InheritableAttr *newAttr =
2475  cast<InheritableParamAttr>(I->clone(S.Context));
2476  newAttr->setInherited(true);
2477  newDecl->addAttr(newAttr);
2478  foundAny = true;
2479  }
2480  }
2481 
2482  if (!foundAny) newDecl->dropAttrs();
2483 }
2484 
2485 static void mergeParamDeclTypes(ParmVarDecl *NewParam,
2486  const ParmVarDecl *OldParam,
2487  Sema &S) {
2488  if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
2489  if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
2490  if (*Oldnullability != *Newnullability) {
2491  S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
2493  *Newnullability,
2495  != 0))
2497  *Oldnullability,
2499  != 0));
2500  S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
2501  }
2502  } else {
2503  QualType NewT = NewParam->getType();
2504  NewT = S.Context.getAttributedType(
2505  AttributedType::getNullabilityAttrKind(*Oldnullability),
2506  NewT, NewT);
2507  NewParam->setType(NewT);
2508  }
2509  }
2510 }
2511 
2512 namespace {
2513 
2514 /// Used in MergeFunctionDecl to keep track of function parameters in
2515 /// C.
2516 struct GNUCompatibleParamWarning {
2517  ParmVarDecl *OldParm;
2518  ParmVarDecl *NewParm;
2519  QualType PromotedType;
2520 };
2521 
2522 }
2523 
2524 /// getSpecialMember - get the special member enum for a method.
2526  if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
2527  if (Ctor->isDefaultConstructor())
2529 
2530  if (Ctor->isCopyConstructor())
2531  return Sema::CXXCopyConstructor;
2532 
2533  if (Ctor->isMoveConstructor())
2534  return Sema::CXXMoveConstructor;
2535  } else if (isa<CXXDestructorDecl>(MD)) {
2536  return Sema::CXXDestructor;
2537  } else if (MD->isCopyAssignmentOperator()) {
2538  return Sema::CXXCopyAssignment;
2539  } else if (MD->isMoveAssignmentOperator()) {
2540  return Sema::CXXMoveAssignment;
2541  }
2542 
2543  return Sema::CXXInvalid;
2544 }
2545 
2546 // Determine whether the previous declaration was a definition, implicit
2547 // declaration, or a declaration.
2548 template <typename T>
2549 static std::pair<diag::kind, SourceLocation>
2550 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
2551  diag::kind PrevDiag;
2552  SourceLocation OldLocation = Old->getLocation();
2553  if (Old->isThisDeclarationADefinition())
2554  PrevDiag = diag::note_previous_definition;
2555  else if (Old->isImplicit()) {
2556  PrevDiag = diag::note_previous_implicit_declaration;
2557  if (OldLocation.isInvalid())
2558  OldLocation = New->getLocation();
2559  } else
2560  PrevDiag = diag::note_previous_declaration;
2561  return std::make_pair(PrevDiag, OldLocation);
2562 }
2563 
2564 /// canRedefineFunction - checks if a function can be redefined. Currently,
2565 /// only extern inline functions can be redefined, and even then only in
2566 /// GNU89 mode.
2567 static bool canRedefineFunction(const FunctionDecl *FD,
2568  const LangOptions& LangOpts) {
2569  return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
2570  !LangOpts.CPlusPlus &&
2571  FD->isInlineSpecified() &&
2572  FD->getStorageClass() == SC_Extern);
2573 }
2574 
2576  const AttributedType *AT = T->getAs<AttributedType>();
2577  while (AT && !AT->isCallingConv())
2578  AT = AT->getModifiedType()->getAs<AttributedType>();
2579  return AT;
2580 }
2581 
2582 template <typename T>
2583 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
2584  const DeclContext *DC = Old->getDeclContext();
2585  if (DC->isRecord())
2586  return false;
2587 
2588  LanguageLinkage OldLinkage = Old->getLanguageLinkage();
2589  if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
2590  return true;
2591  if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
2592  return true;
2593  return false;
2594 }
2595 
2596 template<typename T> static bool isExternC(T *D) { return D->isExternC(); }
2597 static bool isExternC(VarTemplateDecl *) { return false; }
2598 
2599 /// \brief Check whether a redeclaration of an entity introduced by a
2600 /// using-declaration is valid, given that we know it's not an overload
2601 /// (nor a hidden tag declaration).
2602 template<typename ExpectedDecl>
2604  ExpectedDecl *New) {
2605  // C++11 [basic.scope.declarative]p4:
2606  // Given a set of declarations in a single declarative region, each of
2607  // which specifies the same unqualified name,
2608  // -- they shall all refer to the same entity, or all refer to functions
2609  // and function templates; or
2610  // -- exactly one declaration shall declare a class name or enumeration
2611  // name that is not a typedef name and the other declarations shall all
2612  // refer to the same variable or enumerator, or all refer to functions
2613  // and function templates; in this case the class name or enumeration
2614  // name is hidden (3.3.10).
2615 
2616  // C++11 [namespace.udecl]p14:
2617  // If a function declaration in namespace scope or block scope has the
2618  // same name and the same parameter-type-list as a function introduced
2619  // by a using-declaration, and the declarations do not declare the same
2620  // function, the program is ill-formed.
2621 
2622  auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl());
2623  if (Old &&
2624  !Old->getDeclContext()->getRedeclContext()->Equals(
2625  New->getDeclContext()->getRedeclContext()) &&
2626  !(isExternC(Old) && isExternC(New)))
2627  Old = nullptr;
2628 
2629  if (!Old) {
2630  S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2631  S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
2632  S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2633  return true;
2634  }
2635  return false;
2636 }
2637 
2639  const FunctionDecl *B) {
2640  assert(A->getNumParams() == B->getNumParams());
2641 
2642  auto AttrEq = [](const ParmVarDecl *A, const ParmVarDecl *B) {
2643  const auto *AttrA = A->getAttr<PassObjectSizeAttr>();
2644  const auto *AttrB = B->getAttr<PassObjectSizeAttr>();
2645  if (AttrA == AttrB)
2646  return true;
2647  return AttrA && AttrB && AttrA->getType() == AttrB->getType();
2648  };
2649 
2650  return std::equal(A->param_begin(), A->param_end(), B->param_begin(), AttrEq);
2651 }
2652 
2653 /// MergeFunctionDecl - We just parsed a function 'New' from
2654 /// declarator D which has the same name and scope as a previous
2655 /// declaration 'Old'. Figure out how to resolve this situation,
2656 /// merging decls or emitting diagnostics as appropriate.
2657 ///
2658 /// In C++, New and Old must be declarations that are not
2659 /// overloaded. Use IsOverload to determine whether New and Old are
2660 /// overloaded, and to select the Old declaration that New should be
2661 /// merged with.
2662 ///
2663 /// Returns true if there was an error, false otherwise.
2665  Scope *S, bool MergeTypeWithOld) {
2666  // Verify the old decl was also a function.
2667  FunctionDecl *Old = OldD->getAsFunction();
2668  if (!Old) {
2669  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
2670  if (New->getFriendObjectKind()) {
2671  Diag(New->getLocation(), diag::err_using_decl_friend);
2672  Diag(Shadow->getTargetDecl()->getLocation(),
2673  diag::note_using_decl_target);
2674  Diag(Shadow->getUsingDecl()->getLocation(),
2675  diag::note_using_decl) << 0;
2676  return true;
2677  }
2678 
2679  // Check whether the two declarations might declare the same function.
2680  if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
2681  return true;
2682  OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
2683  } else {
2684  Diag(New->getLocation(), diag::err_redefinition_different_kind)
2685  << New->getDeclName();
2686  Diag(OldD->getLocation(), diag::note_previous_definition);
2687  return true;
2688  }
2689  }
2690 
2691  // If the old declaration is invalid, just give up here.
2692  if (Old->isInvalidDecl())
2693  return true;
2694 
2695  diag::kind PrevDiag;
2696  SourceLocation OldLocation;
2697  std::tie(PrevDiag, OldLocation) =
2699 
2700  // Don't complain about this if we're in GNU89 mode and the old function
2701  // is an extern inline function.
2702  // Don't complain about specializations. They are not supposed to have
2703  // storage classes.
2704  if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
2705  New->getStorageClass() == SC_Static &&
2706  Old->hasExternalFormalLinkage() &&
2708  !canRedefineFunction(Old, getLangOpts())) {
2709  if (getLangOpts().MicrosoftExt) {
2710  Diag(New->getLocation(), diag::ext_static_non_static) << New;
2711  Diag(OldLocation, PrevDiag);
2712  } else {
2713  Diag(New->getLocation(), diag::err_static_non_static) << New;
2714  Diag(OldLocation, PrevDiag);
2715  return true;
2716  }
2717  }
2718 
2719  if (New->hasAttr<InternalLinkageAttr>() &&
2720  !Old->hasAttr<InternalLinkageAttr>()) {
2721  Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
2722  << New->getDeclName();
2723  Diag(Old->getLocation(), diag::note_previous_definition);
2724  New->dropAttr<InternalLinkageAttr>();
2725  }
2726 
2727  // If a function is first declared with a calling convention, but is later
2728  // declared or defined without one, all following decls assume the calling
2729  // convention of the first.
2730  //
2731  // It's OK if a function is first declared without a calling convention,
2732  // but is later declared or defined with the default calling convention.
2733  //
2734  // To test if either decl has an explicit calling convention, we look for
2735  // AttributedType sugar nodes on the type as written. If they are missing or
2736  // were canonicalized away, we assume the calling convention was implicit.
2737  //
2738  // Note also that we DO NOT return at this point, because we still have
2739  // other tests to run.
2740  QualType OldQType = Context.getCanonicalType(Old->getType());
2741  QualType NewQType = Context.getCanonicalType(New->getType());
2742  const FunctionType *OldType = cast<FunctionType>(OldQType);
2743  const FunctionType *NewType = cast<FunctionType>(NewQType);
2744  FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
2745  FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
2746  bool RequiresAdjustment = false;
2747 
2748  if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
2749  FunctionDecl *First = Old->getFirstDecl();
2750  const FunctionType *FT =
2752  FunctionType::ExtInfo FI = FT->getExtInfo();
2753  bool NewCCExplicit = getCallingConvAttributedType(New->getType());
2754  if (!NewCCExplicit) {
2755  // Inherit the CC from the previous declaration if it was specified
2756  // there but not here.
2757  NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
2758  RequiresAdjustment = true;
2759  } else {
2760  // Calling conventions aren't compatible, so complain.
2761  bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
2762  Diag(New->getLocation(), diag::err_cconv_change)
2763  << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
2764  << !FirstCCExplicit
2765  << (!FirstCCExplicit ? "" :
2766  FunctionType::getNameForCallConv(FI.getCC()));
2767 
2768  // Put the note on the first decl, since it is the one that matters.
2769  Diag(First->getLocation(), diag::note_previous_declaration);
2770  return true;
2771  }
2772  }
2773 
2774  // FIXME: diagnose the other way around?
2775  if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
2776  NewTypeInfo = NewTypeInfo.withNoReturn(true);
2777  RequiresAdjustment = true;
2778  }
2779 
2780  // Merge regparm attribute.
2781  if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
2782  OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
2783  if (NewTypeInfo.getHasRegParm()) {
2784  Diag(New->getLocation(), diag::err_regparm_mismatch)
2785  << NewType->getRegParmType()
2786  << OldType->getRegParmType();
2787  Diag(OldLocation, diag::note_previous_declaration);
2788  return true;
2789  }
2790 
2791  NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
2792  RequiresAdjustment = true;
2793  }
2794 
2795  // Merge ns_returns_retained attribute.
2796  if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
2797  if (NewTypeInfo.getProducesResult()) {
2798  Diag(New->getLocation(), diag::err_returns_retained_mismatch);
2799  Diag(OldLocation, diag::note_previous_declaration);
2800  return true;
2801  }
2802 
2803  NewTypeInfo = NewTypeInfo.withProducesResult(true);
2804  RequiresAdjustment = true;
2805  }
2806 
2807  if (RequiresAdjustment) {
2808  const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
2809  AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
2810  New->setType(QualType(AdjustedType, 0));
2811  NewQType = Context.getCanonicalType(New->getType());
2812  NewType = cast<FunctionType>(NewQType);
2813  }
2814 
2815  // If this redeclaration makes the function inline, we may need to add it to
2816  // UndefinedButUsed.
2817  if (!Old->isInlined() && New->isInlined() &&
2818  !New->hasAttr<GNUInlineAttr>() &&
2819  !getLangOpts().GNUInline &&
2820  Old->isUsed(false) &&
2821  !Old->isDefined() && !New->isThisDeclarationADefinition())
2822  UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
2823  SourceLocation()));
2824 
2825  // If this redeclaration makes it newly gnu_inline, we don't want to warn
2826  // about it.
2827  if (New->hasAttr<GNUInlineAttr>() &&
2828  Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
2829  UndefinedButUsed.erase(Old->getCanonicalDecl());
2830  }
2831 
2832  // If pass_object_size params don't match up perfectly, this isn't a valid
2833  // redeclaration.
2834  if (Old->getNumParams() > 0 && Old->getNumParams() == New->getNumParams() &&
2835  !hasIdenticalPassObjectSizeAttrs(Old, New)) {
2836  Diag(New->getLocation(), diag::err_different_pass_object_size_params)
2837  << New->getDeclName();
2838  Diag(OldLocation, PrevDiag) << Old << Old->getType();
2839  return true;
2840  }
2841 
2842  if (getLangOpts().CPlusPlus) {
2843  // (C++98 13.1p2):
2844  // Certain function declarations cannot be overloaded:
2845  // -- Function declarations that differ only in the return type
2846  // cannot be overloaded.
2847 
2848  // Go back to the type source info to compare the declared return types,
2849  // per C++1y [dcl.type.auto]p13:
2850  // Redeclarations or specializations of a function or function template
2851  // with a declared return type that uses a placeholder type shall also
2852  // use that placeholder, not a deduced type.
2853  QualType OldDeclaredReturnType =
2854  (Old->getTypeSourceInfo()
2856  : OldType)->getReturnType();
2857  QualType NewDeclaredReturnType =
2858  (New->getTypeSourceInfo()
2860  : NewType)->getReturnType();
2861  QualType ResQT;
2862  if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
2863  !((NewQType->isDependentType() || OldQType->isDependentType()) &&
2864  New->isLocalExternDecl())) {
2865  if (NewDeclaredReturnType->isObjCObjectPointerType() &&
2866  OldDeclaredReturnType->isObjCObjectPointerType())
2867  ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
2868  if (ResQT.isNull()) {
2869  if (New->isCXXClassMember() && New->isOutOfLine())
2870  Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
2871  << New << New->getReturnTypeSourceRange();
2872  else
2873  Diag(New->getLocation(), diag::err_ovl_diff_return_type)
2874  << New->getReturnTypeSourceRange();
2875  Diag(OldLocation, PrevDiag) << Old << Old->getType()
2876  << Old->getReturnTypeSourceRange();
2877  return true;
2878  }
2879  else
2880  NewQType = ResQT;
2881  }
2882 
2883  QualType OldReturnType = OldType->getReturnType();
2884  QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
2885  if (OldReturnType != NewReturnType) {
2886  // If this function has a deduced return type and has already been
2887  // defined, copy the deduced value from the old declaration.
2888  AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
2889  if (OldAT && OldAT->isDeduced()) {
2890  New->setType(
2891  SubstAutoType(New->getType(),
2893  : OldAT->getDeducedType()));
2894  NewQType = Context.getCanonicalType(
2895  SubstAutoType(NewQType,
2897  : OldAT->getDeducedType()));
2898  }
2899  }
2900 
2901  const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
2902  CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
2903  if (OldMethod && NewMethod) {
2904  // Preserve triviality.
2905  NewMethod->setTrivial(OldMethod->isTrivial());
2906 
2907  // MSVC allows explicit template specialization at class scope:
2908  // 2 CXXMethodDecls referring to the same function will be injected.
2909  // We don't want a redeclaration error.
2910  bool IsClassScopeExplicitSpecialization =
2911  OldMethod->isFunctionTemplateSpecialization() &&
2912  NewMethod->isFunctionTemplateSpecialization();
2913  bool isFriend = NewMethod->getFriendObjectKind();
2914 
2915  if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
2916  !IsClassScopeExplicitSpecialization) {
2917  // -- Member function declarations with the same name and the
2918  // same parameter types cannot be overloaded if any of them
2919  // is a static member function declaration.
2920  if (OldMethod->isStatic() != NewMethod->isStatic()) {
2921  Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
2922  Diag(OldLocation, PrevDiag) << Old << Old->getType();
2923  return true;
2924  }
2925 
2926  // C++ [class.mem]p1:
2927  // [...] A member shall not be declared twice in the
2928  // member-specification, except that a nested class or member
2929  // class template can be declared and then later defined.
2930  if (ActiveTemplateInstantiations.empty()) {
2931  unsigned NewDiag;
2932  if (isa<CXXConstructorDecl>(OldMethod))
2933  NewDiag = diag::err_constructor_redeclared;
2934  else if (isa<CXXDestructorDecl>(NewMethod))
2935  NewDiag = diag::err_destructor_redeclared;
2936  else if (isa<CXXConversionDecl>(NewMethod))
2937  NewDiag = diag::err_conv_function_redeclared;
2938  else
2939  NewDiag = diag::err_member_redeclared;
2940 
2941  Diag(New->getLocation(), NewDiag);
2942  } else {
2943  Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
2944  << New << New->getType();
2945  }
2946  Diag(OldLocation, PrevDiag) << Old << Old->getType();
2947  return true;
2948 
2949  // Complain if this is an explicit declaration of a special
2950  // member that was initially declared implicitly.
2951  //
2952  // As an exception, it's okay to befriend such methods in order
2953  // to permit the implicit constructor/destructor/operator calls.
2954  } else if (OldMethod->isImplicit()) {
2955  if (isFriend) {
2956  NewMethod->setImplicit();
2957  } else {
2958  Diag(NewMethod->getLocation(),
2959  diag::err_definition_of_implicitly_declared_member)
2960  << New << getSpecialMember(OldMethod);
2961  return true;
2962  }
2963  } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) {
2964  Diag(NewMethod->getLocation(),
2965  diag::err_definition_of_explicitly_defaulted_member)
2966  << getSpecialMember(OldMethod);
2967  return true;
2968  }
2969  }
2970 
2971  // C++11 [dcl.attr.noreturn]p1:
2972  // The first declaration of a function shall specify the noreturn
2973  // attribute if any declaration of that function specifies the noreturn
2974  // attribute.
2975  const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
2976  if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
2977  Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
2978  Diag(Old->getFirstDecl()->getLocation(),
2979  diag::note_noreturn_missing_first_decl);
2980  }
2981 
2982  // C++11 [dcl.attr.depend]p2:
2983  // The first declaration of a function shall specify the
2984  // carries_dependency attribute for its declarator-id if any declaration
2985  // of the function specifies the carries_dependency attribute.
2986  const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
2987  if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
2988  Diag(CDA->getLocation(),
2989  diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
2990  Diag(Old->getFirstDecl()->getLocation(),
2991  diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
2992  }
2993 
2994  // (C++98 8.3.5p3):
2995  // All declarations for a function shall agree exactly in both the
2996  // return type and the parameter-type-list.
2997  // We also want to respect all the extended bits except noreturn.
2998 
2999  // noreturn should now match unless the old type info didn't have it.
3000  QualType OldQTypeForComparison = OldQType;
3001  if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
3002  assert(OldQType == QualType(OldType, 0));
3003  const FunctionType *OldTypeForComparison
3004  = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
3005  OldQTypeForComparison = QualType(OldTypeForComparison, 0);
3006  assert(OldQTypeForComparison.isCanonical());
3007  }
3008 
3009  if (haveIncompatibleLanguageLinkages(Old, New)) {
3010  // As a special case, retain the language linkage from previous
3011  // declarations of a friend function as an extension.
3012  //
3013  // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
3014  // and is useful because there's otherwise no way to specify language
3015  // linkage within class scope.
3016  //
3017  // Check cautiously as the friend object kind isn't yet complete.
3018  if (New->getFriendObjectKind() != Decl::FOK_None) {
3019  Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
3020  Diag(OldLocation, PrevDiag);
3021  } else {
3022  Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3023  Diag(OldLocation, PrevDiag);
3024  return true;
3025  }
3026  }
3027 
3028  if (OldQTypeForComparison == NewQType)
3029  return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3030 
3031  if ((NewQType->isDependentType() || OldQType->isDependentType()) &&
3032  New->isLocalExternDecl()) {
3033  // It's OK if we couldn't merge types for a local function declaraton
3034  // if either the old or new type is dependent. We'll merge the types
3035  // when we instantiate the function.
3036  return false;
3037  }
3038 
3039  // Fall through for conflicting redeclarations and redefinitions.
3040  }
3041 
3042  // C: Function types need to be compatible, not identical. This handles
3043  // duplicate function decls like "void f(int); void f(enum X);" properly.
3044  if (!getLangOpts().CPlusPlus &&
3045  Context.typesAreCompatible(OldQType, NewQType)) {
3046  const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
3047  const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
3048  const FunctionProtoType *OldProto = nullptr;
3049  if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
3050  (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
3051  // The old declaration provided a function prototype, but the
3052  // new declaration does not. Merge in the prototype.
3053  assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
3054  SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
3055  NewQType =
3056  Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
3057  OldProto->getExtProtoInfo());
3058  New->setType(NewQType);
3059  New->setHasInheritedPrototype();
3060 
3061  // Synthesize parameters with the same types.
3063  for (const auto &ParamType : OldProto->param_types()) {
3065  SourceLocation(), nullptr,
3066  ParamType, /*TInfo=*/nullptr,
3067  SC_None, nullptr);
3068  Param->setScopeInfo(0, Params.size());
3069  Param->setImplicit();
3070  Params.push_back(Param);
3071  }
3072 
3073  New->setParams(Params);
3074  }
3075 
3076  return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3077  }
3078 
3079  // GNU C permits a K&R definition to follow a prototype declaration
3080  // if the declared types of the parameters in the K&R definition
3081  // match the types in the prototype declaration, even when the
3082  // promoted types of the parameters from the K&R definition differ
3083  // from the types in the prototype. GCC then keeps the types from
3084  // the prototype.
3085  //
3086  // If a variadic prototype is followed by a non-variadic K&R definition,
3087  // the K&R definition becomes variadic. This is sort of an edge case, but
3088  // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3089  // C99 6.9.1p8.
3090  if (!getLangOpts().CPlusPlus &&
3091  Old->hasPrototype() && !New->hasPrototype() &&
3092  New->getType()->getAs<FunctionProtoType>() &&
3093  Old->getNumParams() == New->getNumParams()) {
3094  SmallVector<QualType, 16> ArgTypes;
3096  const FunctionProtoType *OldProto
3097  = Old->getType()->getAs<FunctionProtoType>();
3098  const FunctionProtoType *NewProto
3099  = New->getType()->getAs<FunctionProtoType>();
3100 
3101  // Determine whether this is the GNU C extension.
3102  QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3103  NewProto->getReturnType());
3104  bool LooseCompatible = !MergedReturn.isNull();
3105  for (unsigned Idx = 0, End = Old->getNumParams();
3106  LooseCompatible && Idx != End; ++Idx) {
3107  ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3108  ParmVarDecl *NewParm = New->getParamDecl(Idx);
3109  if (Context.typesAreCompatible(OldParm->getType(),
3110  NewProto->getParamType(Idx))) {
3111  ArgTypes.push_back(NewParm->getType());
3112  } else if (Context.typesAreCompatible(OldParm->getType(),
3113  NewParm->getType(),
3114  /*CompareUnqualified=*/true)) {
3115  GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3116  NewProto->getParamType(Idx) };
3117  Warnings.push_back(Warn);
3118  ArgTypes.push_back(NewParm->getType());
3119  } else
3120  LooseCompatible = false;
3121  }
3122 
3123  if (LooseCompatible) {
3124  for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3125  Diag(Warnings[Warn].NewParm->getLocation(),
3126  diag::ext_param_promoted_not_compatible_with_prototype)
3127  << Warnings[Warn].PromotedType
3128  << Warnings[Warn].OldParm->getType();
3129  if (Warnings[Warn].OldParm->getLocation().isValid())
3130  Diag(Warnings[Warn].OldParm->getLocation(),
3131  diag::note_previous_declaration);
3132  }
3133 
3134  if (MergeTypeWithOld)
3135  New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3136  OldProto->getExtProtoInfo()));
3137  return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3138  }
3139 
3140  // Fall through to diagnose conflicting types.
3141  }
3142 
3143  // A function that has already been declared has been redeclared or
3144  // defined with a different type; show an appropriate diagnostic.
3145 
3146  // If the previous declaration was an implicitly-generated builtin
3147  // declaration, then at the very least we should use a specialized note.
3148  unsigned BuiltinID;
3149  if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3150  // If it's actually a library-defined builtin function like 'malloc'
3151  // or 'printf', just warn about the incompatible redeclaration.
3152  if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
3153  Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
3154  Diag(OldLocation, diag::note_previous_builtin_declaration)
3155  << Old << Old->getType();
3156 
3157  // If this is a global redeclaration, just forget hereafter
3158  // about the "builtin-ness" of the function.
3159  //
3160  // Doing this for local extern declarations is problematic. If
3161  // the builtin declaration remains visible, a second invalid
3162  // local declaration will produce a hard error; if it doesn't
3163  // remain visible, a single bogus local redeclaration (which is
3164  // actually only a warning) could break all the downstream code.
3166  New->getIdentifier()->revertBuiltin();
3167 
3168  return false;
3169  }
3170 
3171  PrevDiag = diag::note_previous_builtin_declaration;
3172  }
3173 
3174  Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
3175  Diag(OldLocation, PrevDiag) << Old << Old->getType();
3176  return true;
3177 }
3178 
3179 /// \brief Completes the merge of two function declarations that are
3180 /// known to be compatible.
3181 ///
3182 /// This routine handles the merging of attributes and other
3183 /// properties of function declarations from the old declaration to
3184 /// the new declaration, once we know that New is in fact a
3185 /// redeclaration of Old.
3186 ///
3187 /// \returns false
3189  Scope *S, bool MergeTypeWithOld) {
3190  // Merge the attributes
3191  mergeDeclAttributes(New, Old);
3192 
3193  // Merge "pure" flag.
3194  if (Old->isPure())
3195  New->setPure();
3196 
3197  // Merge "used" flag.
3198  if (Old->getMostRecentDecl()->isUsed(false))
3199  New->setIsUsed();
3200 
3201  // Merge attributes from the parameters. These can mismatch with K&R
3202  // declarations.
3203  if (New->getNumParams() == Old->getNumParams())
3204  for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3205  ParmVarDecl *NewParam = New->getParamDecl(i);
3206  ParmVarDecl *OldParam = Old->getParamDecl(i);
3207  mergeParamDeclAttributes(NewParam, OldParam, *this);
3208  mergeParamDeclTypes(NewParam, OldParam, *this);
3209  }
3210 
3211  if (getLangOpts().CPlusPlus)
3212  return MergeCXXFunctionDecl(New, Old, S);
3213 
3214  // Merge the function types so the we get the composite types for the return
3215  // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3216  // was visible.
3217  QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
3218  if (!Merged.isNull() && MergeTypeWithOld)
3219  New->setType(Merged);
3220 
3221  return false;
3222 }
3223 
3224 
3226  ObjCMethodDecl *oldMethod) {
3227 
3228  // Merge the attributes, including deprecated/unavailable
3229  AvailabilityMergeKind MergeKind =
3230  isa<ObjCProtocolDecl>(oldMethod->getDeclContext())
3231  ? AMK_ProtocolImplementation
3232  : isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3233  : AMK_Override;
3234 
3235  mergeDeclAttributes(newMethod, oldMethod, MergeKind);
3236 
3237  // Merge attributes from the parameters.
3239  oe = oldMethod->param_end();
3241  ni = newMethod->param_begin(), ne = newMethod->param_end();
3242  ni != ne && oi != oe; ++ni, ++oi)
3243  mergeParamDeclAttributes(*ni, *oi, *this);
3244 
3245  CheckObjCMethodOverride(newMethod, oldMethod);
3246 }
3247 
3248 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3249 /// scope as a previous declaration 'Old'. Figure out how to merge their types,
3250 /// emitting diagnostics as appropriate.
3251 ///
3252 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3253 /// to here in AddInitializerToDecl. We can't check them before the initializer
3254 /// is attached.
3256  bool MergeTypeWithOld) {
3257  if (New->isInvalidDecl() || Old->isInvalidDecl())
3258  return;
3259 
3260  QualType MergedT;
3261  if (getLangOpts().CPlusPlus) {
3262  if (New->getType()->isUndeducedType()) {
3263  // We don't know what the new type is until the initializer is attached.
3264  return;
3265  } else if (Context.hasSameType(New->getType(), Old->getType())) {
3266  // These could still be something that needs exception specs checked.
3267  return MergeVarDeclExceptionSpecs(New, Old);
3268  }
3269  // C++ [basic.link]p10:
3270  // [...] the types specified by all declarations referring to a given
3271  // object or function shall be identical, except that declarations for an
3272  // array object can specify array types that differ by the presence or
3273  // absence of a major array bound (8.3.4).
3274  else if (Old->getType()->isIncompleteArrayType() &&
3275  New->getType()->isArrayType()) {
3276  const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3277  const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3278  if (Context.hasSameType(OldArray->getElementType(),
3279  NewArray->getElementType()))
3280  MergedT = New->getType();
3281  } else if (Old->getType()->isArrayType() &&
3282  New->getType()->isIncompleteArrayType()) {
3283  const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3284  const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3285  if (Context.hasSameType(OldArray->getElementType(),
3286  NewArray->getElementType()))
3287  MergedT = Old->getType();
3288  } else if (New->getType()->isObjCObjectPointerType() &&
3289  Old->getType()->isObjCObjectPointerType()) {
3290  MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3291  Old->getType());
3292  }
3293  } else {
3294  // C 6.2.7p2:
3295  // All declarations that refer to the same object or function shall have
3296  // compatible type.
3297  MergedT = Context.mergeTypes(New->getType(), Old->getType());
3298  }
3299  if (MergedT.isNull()) {
3300  // It's OK if we couldn't merge types if either type is dependent, for a
3301  // block-scope variable. In other cases (static data members of class
3302  // templates, variable templates, ...), we require the types to be
3303  // equivalent.
3304  // FIXME: The C++ standard doesn't say anything about this.
3305  if ((New->getType()->isDependentType() ||
3306  Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3307  // If the old type was dependent, we can't merge with it, so the new type
3308  // becomes dependent for now. We'll reproduce the original type when we
3309  // instantiate the TypeSourceInfo for the variable.
3310  if (!New->getType()->isDependentType() && MergeTypeWithOld)
3311  New->setType(Context.DependentTy);
3312  return;
3313  }
3314 
3315  // FIXME: Even if this merging succeeds, some other non-visible declaration
3316  // of this variable might have an incompatible type. For instance:
3317  //
3318  // extern int arr[];
3319  // void f() { extern int arr[2]; }
3320  // void g() { extern int arr[3]; }
3321  //
3322  // Neither C nor C++ requires a diagnostic for this, but we should still try
3323  // to diagnose it.
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  Diag(OldLocation, PrevDiag);
3334  return New->setInvalidDecl();
3335  }
3336 
3337  // Don't actually update the type on the new declaration if the old
3338  // declaration was an extern declaration in a different scope.
3339  if (MergeTypeWithOld)
3340  New->setType(MergedT);
3341 }
3342 
3343 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3345  // C11 6.2.7p4:
3346  // For an identifier with internal or external linkage declared
3347  // in a scope in which a prior declaration of that identifier is
3348  // visible, if the prior declaration specifies internal or
3349  // external linkage, the type of the identifier at the later
3350  // declaration becomes the composite type.
3351  //
3352  // If the variable isn't visible, we do not merge with its type.
3353  if (Previous.isShadowed())
3354  return false;
3355 
3356  if (S.getLangOpts().CPlusPlus) {
3357  // C++11 [dcl.array]p3:
3358  // If there is a preceding declaration of the entity in the same
3359  // scope in which the bound was specified, an omitted array bound
3360  // is taken to be the same as in that earlier declaration.
3361  return NewVD->isPreviousDeclInSameBlockScope() ||
3362  (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3364  } else {
3365  // If the old declaration was function-local, don't merge with its
3366  // type unless we're in the same function.
3367  return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
3368  OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
3369  }
3370 }
3371 
3372 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
3373 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
3374 /// situation, merging decls or emitting diagnostics as appropriate.
3375 ///
3376 /// Tentative definition rules (C99 6.9.2p2) are checked by
3377 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
3378 /// definitions here, since the initializer hasn't been attached.
3379 ///
3381  // If the new decl is already invalid, don't do any other checking.
3382  if (New->isInvalidDecl())
3383  return;
3384 
3385  if (!shouldLinkPossiblyHiddenDecl(Previous, New))
3386  return;
3387 
3388  VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
3389 
3390  // Verify the old decl was also a variable or variable template.
3391  VarDecl *Old = nullptr;
3392  VarTemplateDecl *OldTemplate = nullptr;
3393  if (Previous.isSingleResult()) {
3394  if (NewTemplate) {
3395  OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
3396  Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
3397 
3398  if (auto *Shadow =
3399  dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3400  if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate))
3401  return New->setInvalidDecl();
3402  } else {
3403  Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
3404 
3405  if (auto *Shadow =
3406  dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
3407  if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New))
3408  return New->setInvalidDecl();
3409  }
3410  }
3411  if (!Old) {
3412  Diag(New->getLocation(), diag::err_redefinition_different_kind)
3413  << New->getDeclName();
3414  Diag(Previous.getRepresentativeDecl()->getLocation(),
3415  diag::note_previous_definition);
3416  return New->setInvalidDecl();
3417  }
3418 
3419  // Ensure the template parameters are compatible.
3420  if (NewTemplate &&
3421  !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3422  OldTemplate->getTemplateParameters(),
3423  /*Complain=*/true, TPL_TemplateMatch))
3424  return New->setInvalidDecl();
3425 
3426  // C++ [class.mem]p1:
3427  // A member shall not be declared twice in the member-specification [...]
3428  //
3429  // Here, we need only consider static data members.
3430  if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3431  Diag(New->getLocation(), diag::err_duplicate_member)
3432  << New->getIdentifier();
3433  Diag(Old->getLocation(), diag::note_previous_declaration);
3434  New->setInvalidDecl();
3435  }
3436 
3437  mergeDeclAttributes(New, Old);
3438  // Warn if an already-declared variable is made a weak_import in a subsequent
3439  // declaration
3440  if (New->hasAttr<WeakImportAttr>() &&
3441  Old->getStorageClass() == SC_None &&
3442  !Old->hasAttr<WeakImportAttr>()) {
3443  Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3444  Diag(Old->getLocation(), diag::note_previous_definition);
3445  // Remove weak_import attribute on new declaration.
3446  New->dropAttr<WeakImportAttr>();
3447  }
3448 
3449  if (New->hasAttr<InternalLinkageAttr>() &&
3450  !Old->hasAttr<InternalLinkageAttr>()) {
3451  Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
3452  << New->getDeclName();
3453  Diag(Old->getLocation(), diag::note_previous_definition);
3454  New->dropAttr<InternalLinkageAttr>();
3455  }
3456 
3457  // Merge the types.
3458  VarDecl *MostRecent = Old->getMostRecentDecl();
3459  if (MostRecent != Old) {
3460  MergeVarDeclTypes(New, MostRecent,
3461  mergeTypeWithPrevious(*this, New, MostRecent, Previous));
3462  if (New->isInvalidDecl())
3463  return;
3464  }
3465 
3466  MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
3467  if (New->isInvalidDecl())
3468  return;
3469 
3470  diag::kind PrevDiag;
3471  SourceLocation OldLocation;
3472  std::tie(PrevDiag, OldLocation) =
3474 
3475  // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
3476  if (New->getStorageClass() == SC_Static &&
3477  !New->isStaticDataMember() &&
3478  Old->hasExternalFormalLinkage()) {
3479  if (getLangOpts().MicrosoftExt) {
3480  Diag(New->getLocation(), diag::ext_static_non_static)
3481  << New->getDeclName();
3482  Diag(OldLocation, PrevDiag);
3483  } else {
3484  Diag(New->getLocation(), diag::err_static_non_static)
3485  << New->getDeclName();
3486  Diag(OldLocation, PrevDiag);
3487  return New->setInvalidDecl();
3488  }
3489  }
3490  // C99 6.2.2p4:
3491  // For an identifier declared with the storage-class specifier
3492  // extern in a scope in which a prior declaration of that
3493  // identifier is visible,23) if the prior declaration specifies
3494  // internal or external linkage, the linkage of the identifier at
3495  // the later declaration is the same as the linkage specified at
3496  // the prior declaration. If no prior declaration is visible, or
3497  // if the prior declaration specifies no linkage, then the
3498  // identifier has external linkage.
3499  if (New->hasExternalStorage() && Old->hasLinkage())
3500  /* Okay */;
3501  else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
3502  !New->isStaticDataMember() &&
3504  Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
3505  Diag(OldLocation, PrevDiag);
3506  return New->setInvalidDecl();
3507  }
3508 
3509  // Check if extern is followed by non-extern and vice-versa.
3510  if (New->hasExternalStorage() &&
3511  !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
3512  Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
3513  Diag(OldLocation, PrevDiag);
3514  return New->setInvalidDecl();
3515  }
3516  if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
3517  !New->hasExternalStorage()) {
3518  Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
3519  Diag(OldLocation, PrevDiag);
3520  return New->setInvalidDecl();
3521  }
3522 
3523  // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
3524 
3525  // FIXME: The test for external storage here seems wrong? We still
3526  // need to check for mismatches.
3527  if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
3528  // Don't complain about out-of-line definitions of static members.
3529  !(Old->getLexicalDeclContext()->isRecord() &&
3530  !New->getLexicalDeclContext()->isRecord())) {
3531  Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
3532  Diag(OldLocation, PrevDiag);
3533  return New->setInvalidDecl();
3534  }
3535 
3536  if (New->getTLSKind() != Old->getTLSKind()) {
3537  if (!Old->getTLSKind()) {
3538  Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
3539  Diag(OldLocation, PrevDiag);
3540  } else if (!New->getTLSKind()) {
3541  Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
3542  Diag(OldLocation, PrevDiag);
3543  } else {
3544  // Do not allow redeclaration to change the variable between requiring
3545  // static and dynamic initialization.
3546  // FIXME: GCC allows this, but uses the TLS keyword on the first
3547  // declaration to determine the kind. Do we need to be compatible here?
3548  Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3549  << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
3550  Diag(OldLocation, PrevDiag);
3551  }
3552  }
3553 
3554  // C++ doesn't have tentative definitions, so go right ahead and check here.
3555  VarDecl *Def;
3556  if (getLangOpts().CPlusPlus &&
3558  (Def = Old->getDefinition())) {
3559  NamedDecl *Hidden = nullptr;
3560  if (!hasVisibleDefinition(Def, &Hidden) &&
3561  (New->getFormalLinkage() == InternalLinkage ||
3562  New->getDescribedVarTemplate() ||
3564  New->getDeclContext()->isDependentContext())) {
3565  // The previous definition is hidden, and multiple definitions are
3566  // permitted (in separate TUs). Form another definition of it.
3567  } else {
3568  Diag(New->getLocation(), diag::err_redefinition) << New;
3569  Diag(Def->getLocation(), diag::note_previous_definition);
3570  New->setInvalidDecl();
3571  return;
3572  }
3573  }
3574 
3575  if (haveIncompatibleLanguageLinkages(Old, New)) {
3576  Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3577  Diag(OldLocation, PrevDiag);
3578  New->setInvalidDecl();
3579  return;
3580  }
3581 
3582  // Merge "used" flag.
3583  if (Old->getMostRecentDecl()->isUsed(false))
3584  New->setIsUsed();
3585 
3586  // Keep a chain of previous declarations.
3587  New->setPreviousDecl(Old);
3588  if (NewTemplate)
3589  NewTemplate->setPreviousDecl(OldTemplate);
3590 
3591  // Inherit access appropriately.
3592  New->setAccess(Old->getAccess());
3593  if (NewTemplate)
3594  NewTemplate->setAccess(New->getAccess());
3595 }
3596 
3597 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3598 /// no declarator (e.g. "struct foo;") is parsed.
3600  DeclSpec &DS) {
3601  return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg());
3602 }
3603 
3604 // The MS ABI changed between VS2013 and VS2015 with regard to numbers used to
3605 // disambiguate entities defined in different scopes.
3606 // While the VS2015 ABI fixes potential miscompiles, it is also breaks
3607 // compatibility.
3608 // We will pick our mangling number depending on which version of MSVC is being
3609 // targeted.
3610 static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) {
3612  ? S->getMSCurManglingNumber()
3613  : S->getMSLastManglingNumber();
3614 }
3615 
3616 void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) {
3617  if (!Context.getLangOpts().CPlusPlus)
3618  return;
3619 
3620  if (isa<CXXRecordDecl>(Tag->getParent())) {
3621  // If this tag is the direct child of a class, number it if
3622  // it is anonymous.
3623  if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
3624  return;
3625  MangleNumberingContext &MCtx =
3628  Tag, MCtx.getManglingNumber(
3629  Tag, getMSManglingNumber(getLangOpts(), TagScope)));
3630  return;
3631  }
3632 
3633  // If this tag isn't a direct child of a class, number it if it is local.
3634  Decl *ManglingContextDecl;
3635  if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
3636  Tag->getDeclContext(), ManglingContextDecl)) {
3638  Tag, MCtx->getManglingNumber(
3639  Tag, getMSManglingNumber(getLangOpts(), TagScope)));
3640  }
3641 }
3642 
3644  TypedefNameDecl *NewTD) {
3645  if (TagFromDeclSpec->isInvalidDecl())
3646  return;
3647 
3648  // Do nothing if the tag already has a name for linkage purposes.
3649  if (TagFromDeclSpec->hasNameForLinkage())
3650  return;
3651 
3652  // A well-formed anonymous tag must always be a TUK_Definition.
3653  assert(TagFromDeclSpec->isThisDeclarationADefinition());
3654 
3655  // The type must match the tag exactly; no qualifiers allowed.
3656  if (!Context.hasSameType(NewTD->getUnderlyingType(),
3657  Context.getTagDeclType(TagFromDeclSpec))) {
3658  if (getLangOpts().CPlusPlus)
3659  Context.addTypedefNameForUnnamedTagDecl(TagFromDeclSpec, NewTD);
3660  return;
3661  }
3662 
3663  // If we've already computed linkage for the anonymous tag, then
3664  // adding a typedef name for the anonymous decl can change that
3665  // linkage, which might be a serious problem. Diagnose this as
3666  // unsupported and ignore the typedef name. TODO: we should
3667  // pursue this as a language defect and establish a formal rule
3668  // for how to handle it.
3669  if (TagFromDeclSpec->hasLinkageBeenComputed()) {
3670  Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage);
3671 
3672  SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart();
3673  tagLoc = getLocForEndOfToken(tagLoc);
3674 
3675  llvm::SmallString<40> textToInsert;
3676  textToInsert += ' ';
3677  textToInsert += NewTD->getIdentifier()->getName();
3678  Diag(tagLoc, diag::note_typedef_changes_linkage)
3679  << FixItHint::CreateInsertion(tagLoc, textToInsert);
3680  return;
3681  }
3682 
3683  // Otherwise, set this is the anon-decl typedef for the tag.
3684  TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
3685 }
3686 
3688  switch (T) {
3689  case DeclSpec::TST_class:
3690  return 0;
3691  case DeclSpec::TST_struct:
3692  return 1;
3694  return 2;
3695  case DeclSpec::TST_union:
3696  return 3;
3697  case DeclSpec::TST_enum:
3698  return 4;
3699  default:
3700  llvm_unreachable("unexpected type specifier");
3701  }
3702 }
3703 
3704 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3705 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template
3706 /// parameters to cope with template friend declarations.
3708  DeclSpec &DS,
3709  MultiTemplateParamsArg TemplateParams,
3710  bool IsExplicitInstantiation) {
3711  Decl *TagD = nullptr;
3712  TagDecl *Tag = nullptr;
3713  if (DS.getTypeSpecType() == DeclSpec::TST_class ||
3718  TagD = DS.getRepAsDecl();
3719 
3720  if (!TagD) // We probably had an error
3721  return nullptr;
3722 
3723  // Note that the above type specs guarantee that the
3724  // type rep is a Decl, whereas in many of the others
3725  // it's a Type.
3726  if (isa<TagDecl>(TagD))
3727  Tag = cast<TagDecl>(TagD);
3728  else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
3729  Tag = CTD->getTemplatedDecl();
3730  }
3731 
3732  if (Tag) {
3733  handleTagNumbering(Tag, S);
3734  Tag->setFreeStanding();
3735  if (Tag->isInvalidDecl())
3736  return Tag;
3737  }
3738 
3739  if (unsigned TypeQuals = DS.getTypeQualifiers()) {
3740  // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
3741  // or incomplete types shall not be restrict-qualified."
3742  if (TypeQuals & DeclSpec::TQ_restrict)
3743  Diag(DS.getRestrictSpecLoc(),
3744  diag::err_typecheck_invalid_restrict_not_pointer_noarg)
3745  << DS.getSourceRange();
3746  }
3747 
3748  if (DS.isConstexprSpecified()) {
3749  // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
3750  // and definitions of functions and variables.
3751  if (Tag)
3752  Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
3754  else
3755  Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
3756  // Don't emit warnings after this error.
3757  return TagD;
3758  }
3759 
3760  if (DS.isConceptSpecified()) {
3761  // C++ Concepts TS [dcl.spec.concept]p1: A concept definition refers to
3762  // either a function concept and its definition or a variable concept and
3763  // its initializer.
3764  Diag(DS.getConceptSpecLoc(), diag::err_concept_wrong_decl_kind);
3765  return TagD;
3766  }
3767 
3768  DiagnoseFunctionSpecifiers(DS);
3769 
3770  if (DS.isFriendSpecified()) {
3771  // If we're dealing with a decl but not a TagDecl, assume that
3772  // whatever routines created it handled the friendship aspect.
3773  if (TagD && !Tag)
3774  return nullptr;
3775  return ActOnFriendTypeDecl(S, DS, TemplateParams);
3776  }
3777 
3778  const CXXScopeSpec &SS = DS.getTypeSpecScope();
3779  bool IsExplicitSpecialization =
3780  !TemplateParams.empty() && TemplateParams.back()->size() == 0;
3781  if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
3782  !IsExplicitInstantiation && !IsExplicitSpecialization &&
3783  !isa<ClassTemplatePartialSpecializationDecl>(Tag)) {
3784  // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
3785  // nested-name-specifier unless it is an explicit instantiation
3786  // or an explicit specialization.
3787  //
3788  // FIXME: We allow class template partial specializations here too, per the
3789  // obvious intent of DR1819.
3790  //
3791  // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
3792  Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
3794  return nullptr;
3795  }
3796 
3797  // Track whether this decl-specifier declares anything.
3798  bool DeclaresAnything = true;
3799 
3800  // Handle anonymous struct definitions.
3801  if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
3802  if (!Record->getDeclName() && Record->isCompleteDefinition() &&
3804  if (getLangOpts().CPlusPlus ||
3805  Record->getDeclContext()->isRecord())
3806  return BuildAnonymousStructOrUnion(S, DS, AS, Record,
3808 
3809  DeclaresAnything = false;
3810  }
3811  }
3812 
3813  // C11 6.7.2.1p2:
3814  // A struct-declaration that does not declare an anonymous structure or
3815  // anonymous union shall contain a struct-declarator-list.
3816  //
3817  // This rule also existed in C89 and C99; the grammar for struct-declaration
3818  // did not permit a struct-declaration without a struct-declarator-list.
3819  if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
3821  // Check for Microsoft C extension: anonymous struct/union member.
3822  // Handle 2 kinds of anonymous struct/union:
3823  // struct STRUCT;
3824  // union UNION;
3825  // and
3826  // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
3827  // UNION_TYPE; <- where UNION_TYPE is a typedef union.
3828  if ((Tag && Tag->getDeclName()) ||
3830  RecordDecl *Record = nullptr;
3831  if (Tag)
3832  Record = dyn_cast<RecordDecl>(Tag);
3833  else if (const RecordType *RT =
3835  Record = RT->getDecl();
3836  else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
3837  Record = UT->getDecl();
3838 
3839  if (Record && getLangOpts().MicrosoftExt) {
3840  Diag(DS.getLocStart(), diag::ext_ms_anonymous_record)
3841  << Record->isUnion() << DS.getSourceRange();
3842  return BuildMicrosoftCAnonymousStruct(S, DS, Record);
3843  }
3844 
3845  DeclaresAnything = false;
3846  }
3847  }
3848 
3849  // Skip all the checks below if we have a type error.
3850  if (DS.getTypeSpecType() == DeclSpec::TST_error ||
3851  (TagD && TagD->isInvalidDecl()))
3852  return TagD;
3853 
3854  if (getLangOpts().CPlusPlus &&
3856  if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
3857  if (Enum->enumerator_begin() == Enum->enumerator_end() &&
3858  !Enum->getIdentifier() && !Enum->isInvalidDecl())
3859  DeclaresAnything = false;
3860 
3861  if (!DS.isMissingDeclaratorOk()) {
3862  // Customize diagnostic for a typedef missing a name.
3864  Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
3865  << DS.getSourceRange();
3866  else
3867  DeclaresAnything = false;
3868  }
3869 
3870  if (DS.isModulePrivateSpecified() &&
3871  Tag && Tag->getDeclContext()->isFunctionOrMethod())
3872  Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
3873  << Tag->getTagKind()
3875 
3876  ActOnDocumentableDecl(TagD);
3877 
3878  // C 6.7/2:
3879  // A declaration [...] shall declare at least a declarator [...], a tag,
3880  // or the members of an enumeration.
3881  // C++ [dcl.dcl]p3:
3882  // [If there are no declarators], and except for the declaration of an
3883  // unnamed bit-field, the decl-specifier-seq shall introduce one or more
3884  // names into the program, or shall redeclare a name introduced by a
3885  // previous declaration.
3886  if (!DeclaresAnything) {
3887  // In C, we allow this as a (popular) extension / bug. Don't bother
3888  // producing further diagnostics for redundant qualifiers after this.
3889  Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
3890  return TagD;
3891  }
3892 
3893  // C++ [dcl.stc]p1:
3894  // If a storage-class-specifier appears in a decl-specifier-seq, [...] the
3895  // init-declarator-list of the declaration shall not be empty.
3896  // C++ [dcl.fct.spec]p1:
3897  // If a cv-qualifier appears in a decl-specifier-seq, the
3898  // init-declarator-list of the declaration shall not be empty.
3899  //
3900  // Spurious qualifiers here appear to be valid in C.
3901  unsigned DiagID = diag::warn_standalone_specifier;
3902  if (getLangOpts().CPlusPlus)
3903  DiagID = diag::ext_standalone_specifier;
3904 
3905  // Note that a linkage-specification sets a storage class, but
3906  // 'extern "C" struct foo;' is actually valid and not theoretically
3907  // useless.
3908  if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
3909  if (SCS == DeclSpec::SCS_mutable)
3910  // Since mutable is not a viable storage class specifier in C, there is
3911  // no reason to treat it as an extension. Instead, diagnose as an error.
3912  Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
3913  else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
3914  Diag(DS.getStorageClassSpecLoc(), DiagID)
3916  }
3917 
3918  if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
3919  Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
3920  << DeclSpec::getSpecifierName(TSCS);
3921  if (DS.getTypeQualifiers()) {
3923  Diag(DS.getConstSpecLoc(), DiagID) << "const";
3925  Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
3926  // Restrict is covered above.
3928  Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
3929  }
3930 
3931  // Warn about ignored type attributes, for example:
3932  // __attribute__((aligned)) struct A;
3933  // Attributes should be placed after tag to apply to type declaration.
3934  if (!DS.getAttributes().empty()) {
3935  DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
3936  if (TypeSpecType == DeclSpec::TST_class ||
3937  TypeSpecType == DeclSpec::TST_struct ||
3938  TypeSpecType == DeclSpec::TST_interface ||
3939  TypeSpecType == DeclSpec::TST_union ||
3940  TypeSpecType == DeclSpec::TST_enum) {
3941  for (AttributeList* attrs = DS.getAttributes().getList(); attrs;
3942  attrs = attrs->getNext())
3943  Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
3944  << attrs->getName() << GetDiagnosticTypeSpecifierID(TypeSpecType);
3945  }
3946  }
3947 
3948  return TagD;
3949 }
3950 
3951 /// We are trying to inject an anonymous member into the given scope;
3952 /// check if there's an existing declaration that can't be overloaded.
3953 ///
3954 /// \return true if this is a forbidden redeclaration
3955 static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
3956  Scope *S,
3957  DeclContext *Owner,
3959  SourceLocation NameLoc,
3960  bool IsUnion) {
3961  LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
3963  if (!SemaRef.LookupName(R, S)) return false;
3964 
3965  // Pick a representative declaration.
3967  assert(PrevDecl && "Expected a non-null Decl");
3968 
3969  if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
3970  return false;
3971 
3972  SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl)
3973  << IsUnion << Name;
3974  SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
3975 
3976  return true;
3977 }
3978 
3979 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
3980 /// anonymous struct or union AnonRecord into the owning context Owner
3981 /// and scope S. This routine will be invoked just after we realize
3982 /// that an unnamed union or struct is actually an anonymous union or
3983 /// struct, e.g.,
3984 ///
3985 /// @code
3986 /// union {
3987 /// int i;
3988 /// float f;
3989 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
3990 /// // f into the surrounding scope.x
3991 /// @endcode
3992 ///
3993 /// This routine is recursive, injecting the names of nested anonymous
3994 /// structs/unions into the owning context and scope as well.
3996  DeclContext *Owner,
3997  RecordDecl *AnonRecord,
3998  AccessSpecifier AS,
3999  SmallVectorImpl<NamedDecl *> &Chaining,
4000  bool MSAnonStruct) {
4001  bool Invalid = false;
4002 
4003  // Look every FieldDecl and IndirectFieldDecl with a name.
4004  for (auto *D : AnonRecord->decls()) {
4005  if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
4006  cast<NamedDecl>(D)->getDeclName()) {
4007  ValueDecl *VD = cast<ValueDecl>(D);
4008  if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
4009  VD->getLocation(),
4010  AnonRecord->isUnion())) {
4011  // C++ [class.union]p2:
4012  // The names of the members of an anonymous union shall be
4013  // distinct from the names of any other entity in the
4014  // scope in which the anonymous union is declared.
4015  Invalid = true;
4016  } else {
4017  // C++ [class.union]p2:
4018  // For the purpose of name lookup, after the anonymous union
4019  // definition, the members of the anonymous union are
4020  // considered to have been defined in the scope in which the
4021  // anonymous union is declared.
4022  unsigned OldChainingSize = Chaining.size();
4023  if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
4024  Chaining.append(IF->chain_begin(), IF->chain_end());
4025  else
4026  Chaining.push_back(VD);
4027 
4028  assert(Chaining.size() >= 2);
4029  NamedDecl **NamedChain =
4030  new (SemaRef.Context)NamedDecl*[Chaining.size()];
4031  for (unsigned i = 0; i < Chaining.size(); i++)
4032  NamedChain[i] = Chaining[i];
4033 
4035  SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
4036  VD->getType(), NamedChain, Chaining.size());
4037 
4038  for (const auto *Attr : VD->attrs())
4039  IndirectField->addAttr(Attr->clone(SemaRef.Context));
4040 
4041  IndirectField->setAccess(AS);
4042  IndirectField->setImplicit();
4043  SemaRef.PushOnScopeChains(IndirectField, S);
4044 
4045  // That includes picking up the appropriate access specifier.
4046  if (AS != AS_none) IndirectField->setAccess(AS);
4047 
4048  Chaining.resize(OldChainingSize);
4049  }
4050  }
4051  }
4052 
4053  return Invalid;
4054 }
4055 
4056 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
4057 /// a VarDecl::StorageClass. Any error reporting is up to the caller:
4058 /// illegal input values are mapped to SC_None.
4059 static StorageClass
4061  DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
4062  assert(StorageClassSpec != DeclSpec::SCS_typedef &&
4063  "Parser allowed 'typedef' as storage class VarDecl.");
4064  switch (StorageClassSpec) {
4065  case DeclSpec::SCS_unspecified: return SC_None;
4066  case DeclSpec::SCS_extern:
4067  if (DS.isExternInLinkageSpec())
4068  return SC_None;
4069  return SC_Extern;
4070  case DeclSpec::SCS_static: return SC_Static;
4071  case DeclSpec::SCS_auto: return SC_Auto;
4072  case DeclSpec::SCS_register: return SC_Register;
4074  // Illegal SCSs map to None: error reporting is up to the caller.
4075  case DeclSpec::SCS_mutable: // Fall through.
4076  case DeclSpec::SCS_typedef: return SC_None;
4077  }
4078  llvm_unreachable("unknown storage class specifier");
4079 }
4080 
4082  assert(Record->hasInClassInitializer());
4083 
4084  for (const auto *I : Record->decls()) {
4085  const auto *FD = dyn_cast<FieldDecl>(I);
4086  if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
4087  FD = IFD->getAnonField();
4088  if (FD && FD->hasInClassInitializer())
4089  return FD->getLocation();
4090  }
4091 
4092  llvm_unreachable("couldn't find in-class initializer");
4093 }
4094 
4096  SourceLocation DefaultInitLoc) {
4097  if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4098  return;
4099 
4100  S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
4101  S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
4102 }
4103 
4105  CXXRecordDecl *AnonUnion) {
4106  if (!Parent->isUnion() || !Parent->hasInClassInitializer())
4107  return;
4108 
4109  checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
4110 }
4111 
4112 /// BuildAnonymousStructOrUnion - Handle the declaration of an
4113 /// anonymous structure or union. Anonymous unions are a C++ feature
4114 /// (C++ [class.union]) and a C11 feature; anonymous structures
4115 /// are a C11 feature and GNU C++ extension.
4117  AccessSpecifier AS,
4118  RecordDecl *Record,
4119  const PrintingPolicy &Policy) {
4120  DeclContext *Owner = Record->getDeclContext();
4121 
4122  // Diagnose whether this anonymous struct/union is an extension.
4123  if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
4124  Diag(Record->getLocation(), diag::ext_anonymous_union);
4125  else if (!Record->isUnion() && getLangOpts().CPlusPlus)
4126  Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
4127  else if (!Record->isUnion() && !getLangOpts().C11)
4128  Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
4129 
4130  // C and C++ require different kinds of checks for anonymous
4131  // structs/unions.
4132  bool Invalid = false;
4133  if (getLangOpts().CPlusPlus) {
4134  const char *PrevSpec = nullptr;
4135  unsigned DiagID;
4136  if (Record->isUnion()) {
4137  // C++ [class.union]p6:
4138  // Anonymous unions declared in a named namespace or in the
4139  // global namespace shall be declared static.
4141  (isa<TranslationUnitDecl>(Owner) ||
4142  (isa<NamespaceDecl>(Owner) &&
4143  cast<NamespaceDecl>(Owner)->getDeclName()))) {
4144  Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
4145  << FixItHint::CreateInsertion(Record->getLocation(), "static ");
4146 
4147  // Recover by adding 'static'.
4149  PrevSpec, DiagID, Policy);
4150  }
4151  // C++ [class.union]p6:
4152  // A storage class is not allowed in a declaration of an
4153  // anonymous union in a class scope.
4155  isa<RecordDecl>(Owner)) {
4157  diag::err_anonymous_union_with_storage_spec)
4159 
4160  // Recover by removing the storage specifier.
4162  SourceLocation(),
4163  PrevSpec, DiagID, Context.getPrintingPolicy());
4164  }
4165  }
4166 
4167  // Ignore const/volatile/restrict qualifiers.
4168  if (DS.getTypeQualifiers()) {
4170  Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
4171  << Record->isUnion() << "const"
4174  Diag(DS.getVolatileSpecLoc(),
4175  diag::ext_anonymous_struct_union_qualified)
4176  << Record->isUnion() << "volatile"
4179  Diag(DS.getRestrictSpecLoc(),
4180  diag::ext_anonymous_struct_union_qualified)
4181  << Record->isUnion() << "restrict"
4184  Diag(DS.getAtomicSpecLoc(),
4185  diag::ext_anonymous_struct_union_qualified)
4186  << Record->isUnion() << "_Atomic"
4188 
4189  DS.ClearTypeQualifiers();
4190  }
4191 
4192  // C++ [class.union]p2:
4193  // The member-specification of an anonymous union shall only
4194  // define non-static data members. [Note: nested types and
4195  // functions cannot be declared within an anonymous union. ]
4196  for (auto *Mem : Record->decls()) {
4197  if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
4198  // C++ [class.union]p3:
4199  // An anonymous union shall not have private or protected
4200  // members (clause 11).
4201  assert(FD->getAccess() != AS_none);
4202  if (FD->getAccess() != AS_public) {
4203  Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
4204  << Record->isUnion() << (FD->getAccess() == AS_protected);
4205  Invalid = true;
4206  }
4207 
4208  // C++ [class.union]p1
4209  // An object of a class with a non-trivial constructor, a non-trivial
4210  // copy constructor, a non-trivial destructor, or a non-trivial copy
4211  // assignment operator cannot be a member of a union, nor can an
4212  // array of such objects.
4213  if (CheckNontrivialField(FD))
4214  Invalid = true;
4215  } else if (Mem->isImplicit()) {
4216  // Any implicit members are fine.
4217  } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
4218  // This is a type that showed up in an
4219  // elaborated-type-specifier inside the anonymous struct or
4220  // union, but which actually declares a type outside of the
4221  // anonymous struct or union. It's okay.
4222  } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
4223  if (!MemRecord->isAnonymousStructOrUnion() &&
4224  MemRecord->getDeclName()) {
4225  // Visual C++ allows type definition in anonymous struct or union.
4226  if (getLangOpts().MicrosoftExt)
4227  Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
4228  << Record->isUnion();
4229  else {
4230  // This is a nested type declaration.
4231  Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
4232  << Record->isUnion();
4233  Invalid = true;
4234  }
4235  } else {
4236  // This is an anonymous type definition within another anonymous type.
4237  // This is a popular extension, provided by Plan9, MSVC and GCC, but
4238  // not part of standard C++.
4239  Diag(MemRecord->getLocation(),
4240  diag::ext_anonymous_record_with_anonymous_type)
4241  << Record->isUnion();
4242  }
4243  } else if (isa<AccessSpecDecl>(Mem)) {
4244  // Any access specifier is fine.
4245  } else if (isa<StaticAssertDecl>(Mem)) {
4246  // In C++1z, static_assert declarations are also fine.
4247  } else {
4248  // We have something that isn't a non-static data
4249  // member. Complain about it.
4250  unsigned DK = diag::err_anonymous_record_bad_member;
4251  if (isa<TypeDecl>(Mem))
4252  DK = diag::err_anonymous_record_with_type;
4253  else if (isa<FunctionDecl>(Mem))
4254  DK = diag::err_anonymous_record_with_function;
4255  else if (isa<VarDecl>(Mem))
4256  DK = diag::err_anonymous_record_with_static;
4257 
4258  // Visual C++ allows type definition in anonymous struct or union.
4259  if (getLangOpts().MicrosoftExt &&
4260  DK == diag::err_anonymous_record_with_type)
4261  Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
4262  << Record->isUnion();
4263  else {
4264  Diag(Mem->getLocation(), DK) << Record->isUnion();
4265  Invalid = true;
4266  }
4267  }
4268  }
4269 
4270  // C++11 [class.union]p8 (DR1460):
4271  // At most one variant member of a union may have a
4272  // brace-or-equal-initializer.
4273  if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
4274  Owner->isRecord())
4275  checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
4276  cast<CXXRecordDecl>(Record));
4277  }
4278 
4279  if (!Record->isUnion() && !Owner->isRecord()) {
4280  Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
4281  << getLangOpts().CPlusPlus;
4282  Invalid = true;
4283  }
4284 
4285  // Mock up a declarator.
4287  TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4288  assert(TInfo && "couldn't build declarator info for anonymous struct/union");
4289 
4290  // Create a declaration for this anonymous struct/union.
4291  NamedDecl *Anon = nullptr;
4292  if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
4293  Anon = FieldDecl::Create(Context, OwningClass,
4294  DS.getLocStart(),
4295  Record->getLocation(),
4296  /*IdentifierInfo=*/nullptr,
4297  Context.getTypeDeclType(Record),
4298  TInfo,
4299  /*BitWidth=*/nullptr, /*Mutable=*/false,
4300  /*InitStyle=*/ICIS_NoInit);
4301  Anon->setAccess(AS);
4302  if (getLangOpts().CPlusPlus)
4303  FieldCollector->Add(cast<FieldDecl>(Anon));
4304  } else {
4305  DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
4307  if (SCSpec == DeclSpec::SCS_mutable) {
4308  // mutable can only appear on non-static class members, so it's always
4309  // an error here
4310  Diag(Record->getLocation(), diag::err_mutable_nonmember);
4311  Invalid = true;
4312  SC = SC_None;
4313  }
4314 
4315  Anon = VarDecl::Create(Context, Owner,
4316  DS.getLocStart(),
4317  Record->getLocation(), /*IdentifierInfo=*/nullptr,
4318  Context.getTypeDeclType(Record),
4319  TInfo, SC);
4320 
4321  // Default-initialize the implicit variable. This initialization will be
4322  // trivial in almost all cases, except if a union member has an in-class
4323  // initializer:
4324  // union { int n = 0; };
4325  ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
4326  }
4327  Anon->setImplicit();
4328 
4329  // Mark this as an anonymous struct/union type.
4330  Record->setAnonymousStructOrUnion(true);
4331 
4332  // Add the anonymous struct/union object to the current
4333  // context. We'll be referencing this object when we refer to one of
4334  // its members.
4335  Owner->addDecl(Anon);
4336 
4337  // Inject the members of the anonymous struct/union into the owning
4338  // context and into the identifier resolver chain for name lookup
4339  // purposes.
4341  Chain.push_back(Anon);
4342 
4343  if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
4344  Chain, false))
4345  Invalid = true;
4346 
4347  if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
4348  if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
4349  Decl *ManglingContextDecl;
4350  if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
4351  NewVD->getDeclContext(), ManglingContextDecl)) {
4353  NewVD, MCtx->getManglingNumber(
4354  NewVD, getMSManglingNumber(getLangOpts(), S)));
4355  Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4356  }
4357  }
4358  }
4359 
4360  if (Invalid)
4361  Anon->setInvalidDecl();
4362 
4363  return Anon;
4364 }
4365 
4366 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4367 /// Microsoft C anonymous structure.
4368 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4369 /// Example:
4370 ///
4371 /// struct A { int a; };
4372 /// struct B { struct A; int b; };
4373 ///
4374 /// void foo() {
4375 /// B var;
4376 /// var.a = 3;
4377 /// }
4378 ///
4380  RecordDecl *Record) {
4381  assert(Record && "expected a record!");
4382 
4383  // Mock up a declarator.
4385  TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4386  assert(TInfo && "couldn't build declarator info for anonymous struct");
4387 
4388  auto *ParentDecl = cast<RecordDecl>(CurContext);
4389  QualType RecTy = Context.getTypeDeclType(Record);
4390 
4391  // Create a declaration for this anonymous struct.
4393  ParentDecl,
4394  DS.getLocStart(),
4395  DS.getLocStart(),
4396  /*IdentifierInfo=*/nullptr,
4397  RecTy,
4398  TInfo,
4399  /*BitWidth=*/nullptr, /*Mutable=*/false,
4400  /*InitStyle=*/ICIS_NoInit);
4401  Anon->setImplicit();
4402 
4403  // Add the anonymous struct object to the current context.
4404  CurContext->addDecl(Anon);
4405 
4406  // Inject the members of the anonymous struct into the current
4407  // context and into the identifier resolver chain for name lookup
4408  // purposes.
4410  Chain.push_back(Anon);
4411 
4412  RecordDecl *RecordDef = Record->getDefinition();
4413  if (RequireCompleteType(Anon->getLocation(), RecTy,
4414  diag::err_field_incomplete) ||
4415  InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
4416  AS_none, Chain, true)) {
4417  Anon->setInvalidDecl();
4418  ParentDecl->setInvalidDecl();
4419  }
4420 
4421  return Anon;
4422 }
4423 
4424 /// GetNameForDeclarator - Determine the full declaration name for the
4425 /// given Declarator.
4427  return GetNameFromUnqualifiedId(D.getName());
4428 }
4429 
4430 /// \brief Retrieves the declaration name from a parsed unqualified-id.
4433  DeclarationNameInfo NameInfo;
4434  NameInfo.setLoc(Name.StartLocation);
4435 
4436  switch (Name.getKind()) {
4437 
4440  NameInfo.setName(Name.Identifier);
4441  NameInfo.setLoc(Name.StartLocation);
4442  return NameInfo;
4443 
4447  NameInfo.setLoc(Name.StartLocation);
4451  = Name.EndLocation.getRawEncoding();
4452  return NameInfo;
4453 
4456  Name.Identifier));
4457  NameInfo.setLoc(Name.StartLocation);
4459  return NameInfo;
4460 
4462  TypeSourceInfo *TInfo;
4463  QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4464  if (Ty.isNull())
4465  return DeclarationNameInfo();
4467  Context.getCanonicalType(Ty)));
4468  NameInfo.setLoc(Name.StartLocation);
4469  NameInfo.setNamedTypeInfo(TInfo);
4470  return NameInfo;
4471  }
4472 
4474  TypeSourceInfo *TInfo;
4475  QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
4476  if (Ty.isNull())
4477  return DeclarationNameInfo();
4479  Context.getCanonicalType(Ty)));
4480  NameInfo.setLoc(Name.StartLocation);
4481  NameInfo.setNamedTypeInfo(TInfo);
4482  return NameInfo;
4483  }
4484 
4486  // In well-formed code, we can only have a constructor
4487  // template-id that refers to the current context, so go there
4488  // to find the actual type being constructed.
4489  CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
4490  if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
4491  return DeclarationNameInfo();
4492 
4493  // Determine the type of the class being constructed.
4494  QualType CurClassType = Context.getTypeDeclType(CurClass);
4495 
4496  // FIXME: Check two things: that the template-id names the same type as
4497  // CurClassType, and that the template-id does not occur when the name
4498  // was qualified.
4499 
4501  Context.getCanonicalType(CurClassType)));
4502  NameInfo.setLoc(Name.StartLocation);
4503  // FIXME: should we retrieve TypeSourceInfo?
4504  NameInfo.setNamedTypeInfo(nullptr);
4505  return NameInfo;
4506  }
4507 
4509  TypeSourceInfo *TInfo;
4510  QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
4511  if (Ty.isNull())
4512  return DeclarationNameInfo();
4514  Context.getCanonicalType(Ty)));
4515  NameInfo.setLoc(Name.StartLocation);
4516  NameInfo.setNamedTypeInfo(TInfo);
4517  return NameInfo;
4518  }
4519 
4521  TemplateName TName = Name.TemplateId->Template.get();
4522  SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
4523  return Context.getNameForTemplate(TName, TNameLoc);
4524  }
4525 
4526  } // switch (Name.getKind())
4527 
4528  llvm_unreachable("Unknown name kind");
4529 }
4530 
4532  do {
4533  if (Ty->isPointerType() || Ty->isReferenceType())
4534  Ty = Ty->getPointeeType();
4535  else if (Ty->isArrayType())
4536  Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
4537  else
4538  return Ty.withoutLocalFastQualifiers();
4539  } while (true);
4540 }
4541 
4542 /// hasSimilarParameters - Determine whether the C++ functions Declaration
4543 /// and Definition have "nearly" matching parameters. This heuristic is
4544 /// used to improve diagnostics in the case where an out-of-line function
4545 /// definition doesn't match any declaration within the class or namespace.
4546 /// Also sets Params to the list of indices to the parameters that differ
4547 /// between the declaration and the definition. If hasSimilarParameters
4548 /// returns true and Params is empty, then all of the parameters match.
4550  FunctionDecl *Declaration,
4551  FunctionDecl *Definition,
4552  SmallVectorImpl<unsigned> &Params) {
4553  Params.clear();
4554  if (Declaration->param_size() != Definition->param_size())
4555  return false;
4556  for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
4557  QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
4558  QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
4559 
4560  // The parameter types are identical
4561  if (Context.hasSameType(DefParamTy, DeclParamTy))
4562  continue;
4563 
4564  QualType DeclParamBaseTy = getCoreType(DeclParamTy);
4565  QualType DefParamBaseTy = getCoreType(DefParamTy);
4566  const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
4567  const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
4568 
4569  if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
4570  (DeclTyName && DeclTyName == DefTyName))
4571  Params.push_back(Idx);
4572  else // The two parameters aren't even close
4573  return false;
4574  }
4575 
4576  return true;
4577 }
4578 
4579 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given
4580 /// declarator needs to be rebuilt in the current instantiation.
4581 /// Any bits of declarator which appear before the name are valid for
4582 /// consideration here. That's specifically the type in the decl spec
4583 /// and the base type in any member-pointer chunks.
4586  // The types we specifically need to rebuild are:
4587  // - typenames, typeofs, and decltypes
4588  // - types which will become injected class names
4589  // Of course, we also need to rebuild any type referencing such a
4590  // type. It's safest to just say "dependent", but we call out a
4591  // few cases here.
4592 
4593  DeclSpec &DS = D.getMutableDeclSpec();
4594  switch (DS.getTypeSpecType()) {
4598  case DeclSpec::TST_atomic: {
4599  // Grab the type from the parser.
4600  TypeSourceInfo *TSI = nullptr;
4601  QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
4602  if (T.isNull() || !T->isDependentType()) break;
4603 
4604  // Make sure there's a type source info. This isn't really much
4605  // of a waste; most dependent types should have type source info
4606  // attached already.
4607  if (!TSI)
4609 
4610  // Rebuild the type in the current instantiation.
4612  if (!TSI) return true;
4613 
4614  // Store the new type back in the decl spec.
4615  ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
4616  DS.UpdateTypeRep(LocType);
4617  break;
4618  }
4619 
4621  case DeclSpec::TST_typeofExpr: {
4622  Expr *E = DS.getRepAsExpr();
4624  if (Result.isInvalid()) return true;
4625  DS.UpdateExprRep(Result.get());
4626  break;
4627  }
4628 
4629  default:
4630  // Nothing to do for these decl specs.
4631  break;
4632  }
4633 
4634  // It doesn't matter what order we do this in.
4635  for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4636  DeclaratorChunk &Chunk = D.getTypeObject(I);
4637 
4638  // The only type information in the declarator which can come
4639  // before the declaration name is the base type of a member
4640  // pointer.
4641  if (Chunk.Kind != DeclaratorChunk::MemberPointer)
4642  continue;
4643 
4644  // Rebuild the scope specifier in-place.
4645  CXXScopeSpec &SS = Chunk.Mem.Scope();
4647  return true;
4648  }
4649 
4650  return false;
4651 }
4652 
4655  Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
4656 
4657  if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
4658  Dcl && Dcl->getDeclContext()->isFileContext())
4660 
4661  return Dcl;
4662 }
4663 
4664 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
4665 /// If T is the name of a class, then each of the following shall have a
4666 /// name different from T:
4667 /// - every static data member of class T;
4668 /// - every member function of class T
4669 /// - every member of class T that is itself a type;
4670 /// \returns true if the declaration name violates these rules.
4672  DeclarationNameInfo NameInfo) {
4673  DeclarationName Name = NameInfo.getName();
4674 
4675  CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC);
4676  while (Record && Record->isAnonymousStructOrUnion())
4677  Record = dyn_cast<CXXRecordDecl>(Record->getParent());
4678  if (Record && Record->getIdentifier() && Record->getDeclName() == Name) {
4679  Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
4680  return true;
4681  }
4682 
4683  return false;
4684 }
4685 
4686 /// \brief Diagnose a declaration whose declarator-id has the given
4687 /// nested-name-specifier.
4688 ///
4689 /// \param SS The nested-name-specifier of the declarator-id.
4690 ///
4691 /// \param DC The declaration context to which the nested-name-specifier
4692 /// resolves.
4693 ///
4694 /// \param Name The name of the entity being declared.
4695 ///
4696 /// \param Loc The location of the name of the entity being declared.
4697 ///
4698 /// \returns true if we cannot safely recover from this error, false otherwise.
4701  SourceLocation Loc) {
4702  DeclContext *Cur = CurContext;
4703  while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
4704  Cur = Cur->getParent();
4705 
4706  // If the user provided a superfluous scope specifier that refers back to the
4707  // class in which the entity is already declared, diagnose and ignore it.
4708  //
4709  // class X {
4710  // void X::f();
4711  // };
4712  //
4713  // Note, it was once ill-formed to give redundant qualification in all
4714  // contexts, but that rule was removed by DR482.
4715  if (Cur->Equals(DC)) {
4716  if (Cur->isRecord()) {
4717  Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
4718  : diag::err_member_extra_qualification)
4719  << Name << FixItHint::CreateRemoval(SS.getRange());
4720  SS.clear();
4721  } else {
4722  Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
4723  }
4724  return false;
4725  }
4726 
4727  // Check whether the qualifying scope encloses the scope of the original
4728  // declaration.
4729  if (!Cur->Encloses(DC)) {
4730  if (Cur->isRecord())
4731  Diag(Loc, diag::err_member_qualification)
4732  << Name << SS.getRange();
4733  else if (isa<TranslationUnitDecl>(DC))
4734  Diag(Loc, diag::err_invalid_declarator_global_scope)
4735  << Name << SS.getRange();
4736  else if (isa<FunctionDecl>(Cur))
4737  Diag(Loc, diag::err_invalid_declarator_in_function)
4738  << Name << SS.getRange();
4739  else if (isa<BlockDecl>(Cur))
4740  Diag(Loc, diag::err_invalid_declarator_in_block)
4741  << Name << SS.getRange();
4742  else
4743  Diag(Loc, diag::err_invalid_declarator_scope)
4744  << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
4745 
4746  return true;
4747  }
4748 
4749  if (Cur->isRecord()) {
4750  // Cannot qualify members within a class.
4751  Diag(Loc, diag::err_member_qualification)
4752  << Name << SS.getRange();
4753  SS.clear();
4754 
4755  // C++ constructors and destructors with incorrect scopes can break
4756  // our AST invariants by having the wrong underlying types. If
4757  // that's the case, then drop this declaration entirely.
4761  Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
4762  return true;
4763 
4764  return false;
4765  }
4766 
4767  // C++11 [dcl.meaning]p1:
4768  // [...] "The nested-name-specifier of the qualified declarator-id shall
4769  // not begin with a decltype-specifer"
4770  NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
4771  while (SpecLoc.getPrefix())
4772  SpecLoc = SpecLoc.getPrefix();
4773  if (dyn_cast_or_null<DecltypeType>(
4774  SpecLoc.getNestedNameSpecifier()->getAsType()))
4775  Diag(Loc, diag::err_decltype_in_declarator)
4776  << SpecLoc.getTypeLoc().getSourceRange();
4777 
4778  return false;
4779 }
4780 
4782  MultiTemplateParamsArg TemplateParamLists) {
4783  // TODO: consider using NameInfo for diagnostic.
4784  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4785  DeclarationName Name = NameInfo.getName();
4786 
4787  // All of these full declarators require an identifier. If it doesn't have
4788  // one, the ParsedFreeStandingDeclSpec action should be used.
4789  if (!Name) {
4790  if (!D.isInvalidType()) // Reject this if we think it is valid.
4792  diag::err_declarator_need_ident)
4793  << D.getDeclSpec().getSourceRange() << D.getSourceRange();
4794  return nullptr;
4795  } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
4796  return nullptr;
4797 
4798  // The scope passed in may not be a decl scope. Zip up the scope tree until
4799  // we find one that is.
4800  while ((S->getFlags() & Scope::DeclScope) == 0 ||
4801  (S->getFlags() & Scope::TemplateParamScope) != 0)
4802  S = S->getParent();
4803 
4804  DeclContext *DC = CurContext;
4805  if (D.getCXXScopeSpec().isInvalid())
4806  D.setInvalidType();
4807  else if (D.getCXXScopeSpec().isSet()) {
4808  if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
4809  UPPC_DeclarationQualifier))
4810  return nullptr;
4811 
4812  bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
4813  DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
4814  if (!DC || isa<EnumDecl>(DC)) {
4815  // If we could not compute the declaration context, it's because the
4816  // declaration context is dependent but does not refer to a class,
4817  // class template, or class template partial specialization. Complain
4818  // and return early, to avoid the coming semantic disaster.
4819  Diag(D.getIdentifierLoc(),
4820  diag::err_template_qualified_declarator_no_match)
4821  << D.getCXXScopeSpec().getScopeRep()
4822  << D.getCXXScopeSpec().getRange();
4823  return nullptr;
4824  }
4825  bool IsDependentContext = DC->isDependentContext();
4826 
4827  if (!IsDependentContext &&
4828  RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
4829  return nullptr;
4830 
4831  // If a class is incomplete, do not parse entities inside it.
4832  if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
4833  Diag(D.getIdentifierLoc(),
4834  diag::err_member_def_undefined_record)
4835  << Name << DC << D.getCXXScopeSpec().getRange();
4836  return nullptr;
4837  }
4838  if (!D.getDeclSpec().isFriendSpecified()) {
4839  if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
4840  Name, D.getIdentifierLoc())) {
4841  if (DC->isRecord())
4842  return nullptr;
4843 
4844  D.setInvalidType();
4845  }
4846  }
4847 
4848  // Check whether we need to rebuild the type of the given
4849  // declaration in the current instantiation.
4850  if (EnteringContext && IsDependentContext &&
4851  TemplateParamLists.size() != 0) {
4852  ContextRAII SavedContext(*this, DC);
4853  if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
4854  D.setInvalidType();
4855  }
4856  }
4857 
4858  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4859  QualType R = TInfo->getType();
4860 
4861  if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo))
4862  // If this is a typedef, we'll end up spewing multiple diagnostics.
4863  // Just return early; it's safer. If this is a function, let the
4864  // "constructor cannot have a return type" diagnostic handle it.
4866  return nullptr;
4867 
4868  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
4869  UPPC_DeclarationType))
4870  D.setInvalidType();
4871 
4872  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
4873  ForRedeclaration);
4874 
4875  // See if this is a redefinition of a variable in the same scope.
4876  if (!D.getCXXScopeSpec().isSet()) {
4877  bool IsLinkageLookup = false;
4878  bool CreateBuiltins = false;
4879 
4880  // If the declaration we're planning to build will be a function
4881  // or object with linkage, then look for another declaration with
4882  // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
4883  //
4884  // If the declaration we're planning to build will be declared with
4885  // external linkage in the translation unit, create any builtin with
4886  // the same name.
4888  /* Do nothing*/;
4889  else if (CurContext->isFunctionOrMethod() &&
4891  R->isFunctionType())) {
4892  IsLinkageLookup = true;
4893  CreateBuiltins =
4894  CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
4895  } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
4897  CreateBuiltins = true;
4898 
4899  if (IsLinkageLookup)
4900  Previous.clear(LookupRedeclarationWithLinkage);
4901 
4902  LookupName(Previous, S, CreateBuiltins);
4903  } else { // Something like "int foo::x;"
4904  LookupQualifiedName(Previous, DC);
4905 
4906  // C++ [dcl.meaning]p1:
4907  // When the declarator-id is qualified, the declaration shall refer to a
4908  // previously declared member of the class or namespace to which the
4909  // qualifier refers (or, in the case of a namespace, of an element of the
4910  // inline namespace set of that namespace (7.3.1)) or to a specialization
4911  // thereof; [...]
4912  //
4913  // Note that we already checked the context above, and that we do not have
4914  // enough information to make sure that Previous contains the declaration
4915  // we want to match. For example, given:
4916  //
4917  // class X {
4918  // void f();
4919  // void f(float);
4920  // };
4921  //
4922  // void X::f(int) { } // ill-formed
4923  //
4924  // In this case, Previous will point to the overload set
4925  // containing the two f's declared in X, but neither of them
4926  // matches.
4927 
4928  // C++ [dcl.meaning]p1:
4929  // [...] the member shall not merely have been introduced by a
4930  // using-declaration in the scope of the class or namespace nominated by
4931  // the nested-name-specifier of the declarator-id.
4932  RemoveUsingDecls(Previous);
4933  }
4934 
4935  if (Previous.isSingleResult() &&
4936  Previous.getFoundDecl()->isTemplateParameter()) {
4937  // Maybe we will complain about the shadowed template parameter.
4938  if (!D.isInvalidType())
4939  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
4940  Previous.getFoundDecl());
4941 
4942  // Just pretend that we didn't see the previous declaration.
4943  Previous.clear();
4944  }
4945 
4946  // In C++, the previous declaration we find might be a tag type
4947  // (class or enum). In this case, the new declaration will hide the
4948  // tag type. Note that this does does not apply if we're declaring a
4949  // typedef (C++ [dcl.typedef]p4).
4950  if (Previous.isSingleTagDecl() &&
4952  Previous.clear();
4953 
4954  // Check that there are no default arguments other than in the parameters
4955  // of a function declaration (C++ only).
4956  if (getLangOpts().CPlusPlus)
4957  CheckExtraCXXDefaultArguments(D);
4958 
4959  if (D.getDeclSpec().isConceptSpecified()) {
4960  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
4961  // applied only to the definition of a function template or variable
4962  // template, declared in namespace scope
4963  if (!TemplateParamLists.size()) {
4965  diag:: err_concept_wrong_decl_kind);
4966  return nullptr;
4967  }
4968 
4969  if (!DC->getRedeclContext()->isFileContext()) {
4970  Diag(D.getIdentifierLoc(),
4971  diag::err_concept_decls_may_only_appear_in_namespace_scope);
4972  return nullptr;
4973  }
4974  }
4975 
4976  NamedDecl *New;
4977 
4978  bool AddToScope = true;
4980  if (TemplateParamLists.size()) {
4981  Diag(D.getIdentifierLoc(), diag::err_template_typedef);
4982  return nullptr;
4983  }
4984 
4985  New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
4986  } else if (R->isFunctionType()) {
4987  New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
4988  TemplateParamLists,
4989  AddToScope);
4990  } else {
4991  New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
4992  AddToScope);
4993  }
4994 
4995  if (!New)
4996  return nullptr;
4997 
4998  // If this has an identifier and is not an invalid redeclaration or
4999  // function template specialization, add it to the scope stack.
5000  if (New->getDeclName() && AddToScope &&
5001  !(D.isRedeclaration() && New->isInvalidDecl())) {
5002  // Only make a locally-scoped extern declaration visible if it is the first
5003  // declaration of this entity. Qualified lookup for such an entity should
5004  // only find this declaration if there is no visible declaration of it.
5005  bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
5006  PushOnScopeChains(New, S, AddToContext);
5007  if (!AddToContext)
5008  CurContext->addHiddenDecl(New);
5009  }
5010 
5011  return New;
5012 }
5013 
5014 /// Helper method to turn variable array types into constant array
5015 /// types in certain situations which would otherwise be errors (for
5016 /// GCC compatibility).
5019  bool &SizeIsNegative,
5020  llvm::APSInt &Oversized) {
5021  // This method tries to turn a variable array into a constant
5022  // array even when the size isn't an ICE. This is necessary
5023  // for compatibility with code that depends on gcc's buggy
5024  // constant expression folding, like struct {char x[(int)(char*)2];}
5025  SizeIsNegative = false;
5026  Oversized = 0;
5027 
5028  if (T->isDependentType())
5029  return QualType();
5030 
5031  QualifierCollector Qs;
5032  const Type *Ty = Qs.strip(T);
5033 
5034  if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
5035  QualType Pointee = PTy->getPointeeType();
5036  QualType FixedType =
5037  TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
5038  Oversized);
5039  if (FixedType.isNull()) return FixedType;
5040  FixedType = Context.getPointerType(FixedType);
5041  return Qs.apply(Context, FixedType);
5042  }
5043  if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
5044  QualType Inner = PTy->getInnerType();
5045  QualType FixedType =
5046  TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
5047  Oversized);
5048  if (FixedType.isNull()) return FixedType;
5049  FixedType = Context.getParenType(FixedType);
5050  return Qs.apply(Context, FixedType);
5051  }
5052 
5053  const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
5054  if (!VLATy)
5055  return QualType();
5056  // FIXME: We should probably handle this case
5057  if (VLATy->getElementType()->isVariablyModifiedType())
5058  return QualType();
5059 
5060  llvm::APSInt Res;
5061  if (!VLATy->getSizeExpr() ||
5062  !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
5063  return QualType();
5064 
5065  // Check whether the array size is negative.
5066  if (Res.isSigned() && Res.isNegative()) {
5067  SizeIsNegative = true;
5068  return QualType();
5069  }
5070 
5071  // Check whether the array is too large to be addressed.
5072  unsigned ActiveSizeBits
5074  Res);
5075  if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
5076  Oversized = Res;
5077  return QualType();
5078  }
5079 
5080  return Context.getConstantArrayType(VLATy->getElementType(),
5081  Res, ArrayType::Normal, 0);
5082 }
5083 
5084 static void
5086  SrcTL = SrcTL.getUnqualifiedLoc();
5087  DstTL = DstTL.getUnqualifiedLoc();
5088  if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
5089  PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
5090  FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
5091  DstPTL.getPointeeLoc());
5092  DstPTL.setStarLoc(SrcPTL.getStarLoc());
5093  return;
5094  }
5095  if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
5096  ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
5097  FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
5098  DstPTL.getInnerLoc());
5099  DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
5100  DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
5101  return;
5102  }
5103  ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
5104  ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
5105  TypeLoc SrcElemTL = SrcATL.getElementLoc();
5106  TypeLoc DstElemTL = DstATL.getElementLoc();
5107  DstElemTL.initializeFullCopy(SrcElemTL);
5108  DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
5109  DstATL.setSizeExpr(SrcATL.getSizeExpr());
5110  DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
5111 }
5112 
5113 /// Helper method to turn variable array types into constant array
5114 /// types in certain situations which would otherwise be errors (for
5115 /// GCC compatibility).
5116 static TypeSourceInfo*
5119  bool &SizeIsNegative,
5120  llvm::APSInt &Oversized) {
5121  QualType FixedTy
5123  SizeIsNegative, Oversized);
5124  if (FixedTy.isNull())
5125  return nullptr;
5126  TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
5128  FixedTInfo->getTypeLoc());
5129  return FixedTInfo;
5130 }
5131 
5132 /// \brief Register the given locally-scoped extern "C" declaration so
5133 /// that it can be found later for redeclarations. We include any extern "C"
5134 /// declaration that is not visible in the translation unit here, not just
5135 /// function-scope declarations.
5136 void
5138  if (!getLangOpts().CPlusPlus &&
5140  // Don't need to track declarations in the TU in C.
5141  return;
5142 
5143  // Note that we have a locally-scoped external with this name.
5145 }
5146 
5148  // FIXME: We can have multiple results via __attribute__((overloadable)).
5149  auto Result = Context.getExternCContextDecl()->lookup(Name);
5150  return Result.empty() ? nullptr : *Result.begin();
5151 }
5152 
5153 /// \brief Diagnose function specifiers on a declaration of an identifier that
5154 /// does not identify a function.
5156  // FIXME: We should probably indicate the identifier in question to avoid
5157  // confusion for constructs like "inline int a(), b;"
5158  if (DS.isInlineSpecified())
5159  Diag(DS.getInlineSpecLoc(),
5160  diag::err_inline_non_function);
5161 
5162  if (DS.isVirtualSpecified())
5163  Diag(DS.getVirtualSpecLoc(),
5164  diag::err_virtual_non_function);
5165 
5166  if (DS.isExplicitSpecified())
5167  Diag(DS.getExplicitSpecLoc(),
5168  diag::err_explicit_non_function);
5169 
5170  if (DS.isNoreturnSpecified())
5171  Diag(DS.getNoreturnSpecLoc(),
5172  diag::err_noreturn_non_function);
5173 }
5174 
5175 NamedDecl*
5178  // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
5179  if (D.getCXXScopeSpec().isSet()) {
5180  Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
5181  << D.getCXXScopeSpec().getRange();
5182  D.setInvalidType();
5183  // Pretend we didn't see the scope specifier.
5184  DC = CurContext;
5185  Previous.clear();
5186  }
5187 
5188  DiagnoseFunctionSpecifiers(D.getDeclSpec());
5189 
5191  Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
5192  << 1;
5193  if (D.getDeclSpec().isConceptSpecified())
5195  diag::err_concept_wrong_decl_kind);
5196 
5198  Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
5199  << D.getName().getSourceRange();
5200  return nullptr;
5201  }
5202 
5203  TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
5204  if (!NewTD) return nullptr;
5205 
5206  // Handle attributes prior to checking for duplicates in MergeVarDecl
5207  ProcessDeclAttributes(S, NewTD, D);
5208 
5209  CheckTypedefForVariablyModifiedType(S, NewTD);
5210 
5211  bool Redeclaration = D.isRedeclaration();
5212  NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
5213  D.setRedeclaration(Redeclaration);
5214  return ND;
5215 }
5216 
5217 void
5219  // C99 6.7.7p2: If a typedef name specifies a variably modified type
5220  // then it shall have block scope.
5221  // Note that variably modified types must be fixed before merging the decl so
5222  // that redeclarations will match.
5223  TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
5224  QualType T = TInfo->getType();
5225  if (T->isVariablyModifiedType()) {
5226  getCurFunction()->setHasBranchProtectedScope();
5227 
5228  if (S->getFnParent() == nullptr) {
5229  bool SizeIsNegative;
5230  llvm::APSInt Oversized;
5231  TypeSourceInfo *FixedTInfo =
5233  SizeIsNegative,
5234  Oversized);
5235  if (FixedTInfo) {
5236  Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
5237  NewTD->setTypeSourceInfo(FixedTInfo);
5238  } else {
5239  if (SizeIsNegative)
5240  Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
5241  else if (T->isVariableArrayType())
5242  Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
5243  else if (Oversized.getBoolValue())
5244  Diag(NewTD->getLocation(), diag::err_array_too_large)
5245  << Oversized.toString(10);
5246  else
5247  Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
5248  NewTD->setInvalidDecl();
5249  }
5250  }
5251  }
5252 }
5253 
5254 
5255 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
5256 /// declares a typedef-name, either using the 'typedef' type specifier or via
5257 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
5258 NamedDecl*
5260  LookupResult &Previous, bool &Redeclaration) {
5261  // Merge the decl with the existing one if appropriate. If the decl is
5262  // in an outer scope, it isn't the same thing.
5263  FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
5264  /*AllowInlineNamespace*/false);
5265  filterNonConflictingPreviousTypedefDecls(*this, NewTD, Previous);
5266  if (!Previous.empty()) {
5267  Redeclaration = true;
5268  MergeTypedefNameDecl(S, NewTD, Previous);
5269  }
5270 
5271  // If this is the C FILE type, notify the AST context.
5272  if (IdentifierInfo *II = NewTD->getIdentifier())
5273  if (!NewTD->isInvalidDecl() &&
5275  if (II->isStr("FILE"))
5276  Context.setFILEDecl(NewTD);
5277  else if (II->isStr("jmp_buf"))
5278  Context.setjmp_bufDecl(NewTD);
5279  else if (II->isStr("sigjmp_buf"))
5280  Context.setsigjmp_bufDecl(NewTD);
5281  else if (II->isStr("ucontext_t"))
5282  Context.setucontext_tDecl(NewTD);
5283  }
5284 
5285  return NewTD;
5286 }
5287 
5288 /// \brief Determines whether the given declaration is an out-of-scope
5289 /// previous declaration.
5290 ///
5291 /// This routine should be invoked when name lookup has found a
5292 /// previous declaration (PrevDecl) that is not in the scope where a
5293 /// new declaration by the same name is being introduced. If the new
5294 /// declaration occurs in a local scope, previous declarations with
5295 /// linkage may still be considered previous declarations (C99
5296 /// 6.2.2p4-5, C++ [basic.link]p6).
5297 ///
5298 /// \param PrevDecl the previous declaration found by name
5299 /// lookup
5300 ///
5301 /// \param DC the context in which the new declaration is being
5302 /// declared.
5303 ///
5304 /// \returns true if PrevDecl is an out-of-scope previous declaration
5305 /// for a new delcaration with the same name.
5306 static bool
5308  ASTContext &Context) {
5309  if (!PrevDecl)
5310  return false;
5311 
5312  if (!PrevDecl->hasLinkage())
5313  return false;
5314 
5315  if (Context.getLangOpts().CPlusPlus) {
5316  // C++ [basic.link]p6:
5317  // If there is a visible declaration of an entity with linkage
5318  // having the same name and type, ignoring entities declared
5319  // outside the innermost enclosing namespace scope, the block
5320  // scope declaration declares that same entity and receives the
5321  // linkage of the previous declaration.
5322  DeclContext *OuterContext = DC->getRedeclContext();
5323  if (!OuterContext->isFunctionOrMethod())
5324  // This rule only applies to block-scope declarations.
5325  return false;
5326 
5327  DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
5328  if (PrevOuterContext->isRecord())
5329  // We found a member function: ignore it.
5330  return false;
5331 
5332  // Find the innermost enclosing namespace for the new and
5333  // previous declarations.
5334  OuterContext = OuterContext->getEnclosingNamespaceContext();
5335  PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
5336 
5337  // The previous declaration is in a different namespace, so it
5338  // isn't the same function.
5339  if (!OuterContext->Equals(PrevOuterContext))
5340  return false;
5341  }
5342 
5343  return true;
5344 }
5345 
5347  CXXScopeSpec &SS = D.getCXXScopeSpec();
5348  if (!SS.isSet()) return;
5350 }
5351 
5353  QualType type = decl->getType();
5354  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5355  if (lifetime == Qualifiers::OCL_Autoreleasing) {
5356  // Various kinds of declaration aren't allowed to be __autoreleasing.
5357  unsigned kind = -1U;
5358  if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5359  if (var->hasAttr<BlocksAttr>())
5360  kind = 0; // __block
5361  else if (!var->hasLocalStorage())
5362  kind = 1; // global
5363  } else if (isa<ObjCIvarDecl>(decl)) {
5364  kind = 3; // ivar
5365  } else if (isa<FieldDecl>(decl)) {
5366  kind = 2; // field
5367  }
5368 
5369  if (kind != -1U) {
5370  Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
5371  << kind;
5372  }
5373  } else if (lifetime == Qualifiers::OCL_None) {
5374  // Try to infer lifetime.
5375  if (!type->isObjCLifetimeType())
5376  return false;
5377 
5378  lifetime = type->getObjCARCImplicitLifetime();
5379  type = Context.getLifetimeQualifiedType(type, lifetime);
5380  decl->setType(type);
5381  }
5382 
5383  if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5384  // Thread-local variables cannot have lifetime.
5385  if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
5386  var->getTLSKind()) {
5387  Diag(var->getLocation(), diag::err_arc_thread_ownership)
5388  << var->getType();
5389  return true;
5390  }
5391  }
5392 
5393  return false;
5394 }
5395 
5397  // Ensure that an auto decl is deduced otherwise the checks below might cache
5398  // the wrong linkage.
5399  assert(S.ParsingInitForAutoVars.count(&ND) == 0);
5400 
5401  // 'weak' only applies to declarations with external linkage.
5402  if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
5403  if (!ND.isExternallyVisible()) {
5404  S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5405  ND.dropAttr<WeakAttr>();
5406  }
5407  }
5408  if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
5409  if (ND.isExternallyVisible()) {
5410  S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5411  ND.dropAttr<WeakRefAttr>();
5412  ND.dropAttr<AliasAttr>();
5413  }
5414  }
5415 
5416  if (auto *VD = dyn_cast<VarDecl>(&ND)) {
5417  if (VD->hasInit()) {
5418  if (const auto *Attr = VD->getAttr<AliasAttr>()) {
5419  assert(VD->isThisDeclarationADefinition() &&
5420  !VD->isExternallyVisible() && "Broken AliasAttr handled late!");
5421  S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD;
5422  VD->dropAttr<AliasAttr>();
5423  }
5424  }
5425  }
5426 
5427  // 'selectany' only applies to externally visible variable declarations.
5428  // It does not apply to functions.
5429  if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5430  if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
5431  S.Diag(Attr->getLocation(),
5432  diag::err_attribute_selectany_non_extern_data);
5433  ND.dropAttr<SelectAnyAttr>();
5434  }
5435  }
5436 
5437  if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
5438  // dll attributes require external linkage. Static locals may have external
5439  // linkage but still cannot be explicitly imported or exported.
5440  auto *VD = dyn_cast<VarDecl>(&ND);
5441  if (!ND.isExternallyVisible() || (VD && VD->isStaticLocal())) {
5442  S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5443  << &ND << Attr;
5444  ND.setInvalidDecl();
5445  }
5446  }
5447 
5448  // Virtual functions cannot be marked as 'notail'.
5449  if (auto *Attr = ND.getAttr<NotTailCalledAttr>())
5450  if (auto *MD = dyn_cast<CXXMethodDecl>(&ND))
5451  if (MD->isVirtual()) {
5452  S.Diag(ND.getLocation(),
5453  diag::err_invalid_attribute_on_virtual_function)
5454  << Attr;
5455  ND.dropAttr<NotTailCalledAttr>();
5456  }
5457 }
5458 
5460  NamedDecl *NewDecl,
5461  bool IsSpecialization) {
5462  if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl))
5463  OldDecl = OldTD->getTemplatedDecl();
5464  if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl))
5465  NewDecl = NewTD->getTemplatedDecl();
5466 
5467  if (!OldDecl || !NewDecl)
5468  return;
5469 
5470  const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
5471  const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
5472  const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
5473  const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
5474 
5475  // dllimport and dllexport are inheritable attributes so we have to exclude
5476  // inherited attribute instances.
5477  bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
5478  (NewExportAttr && !NewExportAttr->isInherited());
5479 
5480  // A redeclaration is not allowed to add a dllimport or dllexport attribute,
5481  // the only exception being explicit specializations.
5482  // Implicitly generated declarations are also excluded for now because there
5483  // is no other way to switch these to use dllimport or dllexport.
5484  bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
5485 
5486  if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
5487  // Allow with a warning for free functions and global variables.
5488  bool JustWarn = false;
5489  if (!OldDecl->isCXXClassMember()) {
5490  auto *VD = dyn_cast<VarDecl>(OldDecl);
5491  if (VD && !VD->getDescribedVarTemplate())
5492  JustWarn = true;
5493  auto *FD = dyn_cast<FunctionDecl>(OldDecl);
5494  if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
5495  JustWarn = true;
5496  }
5497 
5498  // We cannot change a declaration that's been used because IR has already
5499  // been emitted. Dllimported functions will still work though (modulo
5500  // address equality) as they can use the thunk.
5501  if (OldDecl->isUsed())
5502  if (!isa<FunctionDecl>(OldDecl) || !NewImportAttr)
5503  JustWarn = false;
5504 
5505  unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
5506  : diag::err_attribute_dll_redeclaration;
5507  S.Diag(NewDecl->getLocation(), DiagID)
5508  << NewDecl
5509  << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
5510  S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5511  if (!JustWarn) {
5512  NewDecl->setInvalidDecl();
5513  return;
5514  }
5515  }
5516 
5517  // A redeclaration is not allowed to drop a dllimport attribute, the only
5518  // exceptions being inline function definitions, local extern declarations,
5519  // and qualified friend declarations.
5520  // NB: MSVC converts such a declaration to dllexport.
5521  bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
5522  if (const auto *VD = dyn_cast<VarDecl>(NewDecl))
5523  // Ignore static data because out-of-line definitions are diagnosed
5524  // separately.
5525  IsStaticDataMember = VD->isStaticDataMember();
5526  else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
5527  IsInline = FD->isInlined();
5528  IsQualifiedFriend = FD->getQualifier() &&
5529  FD->getFriendObjectKind() == Decl::FOK_Declared;
5530  }
5531 
5532  if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember &&
5533  !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
5534  S.Diag(NewDecl->getLocation(),
5535  diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
5536  << NewDecl << OldImportAttr;
5537  S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5538  S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
5539  OldDecl->dropAttr<DLLImportAttr>();
5540  NewDecl->dropAttr<DLLImportAttr>();
5541  } else if (IsInline && OldImportAttr &&
5543  // In MinGW, seeing a function declared inline drops the dllimport attribute.
5544  OldDecl->dropAttr<DLLImportAttr>();
5545  NewDecl->dropAttr<DLLImportAttr>();
5546  S.Diag(NewDecl->getLocation(),
5547  diag::warn_dllimport_dropped_from_inline_function)
5548  << NewDecl << OldImportAttr;
5549  }
5550 }
5551 
5552 /// Given that we are within the definition of the given function,
5553 /// will that definition behave like C99's 'inline', where the
5554 /// definition is discarded except for optimization purposes?
5556  // Try to avoid calling GetGVALinkageForFunction.
5557 
5558  // All cases of this require the 'inline' keyword.
5559  if (!FD->isInlined()) return false;
5560 
5561  // This is only possible in C++ with the gnu_inline attribute.
5562  if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
5563  return false;
5564 
5565  // Okay, go ahead and call the relatively-more-expensive function.
5566 
5567 #ifndef NDEBUG
5568  // AST quite reasonably asserts that it's working on a function
5569  // definition. We don't really have a way to tell it that we're
5570  // currently defining the function, so just lie to it in +Asserts
5571  // builds. This is an awful hack.
5572  FD->setLazyBody(1);
5573 #endif
5574 
5575  bool isC99Inline =
5577 
5578 #ifndef NDEBUG
5579  FD->setLazyBody(0);
5580 #endif
5581 
5582  return isC99Inline;
5583 }
5584 
5585 /// Determine whether a variable is extern "C" prior to attaching
5586 /// an initializer. We can't just call isExternC() here, because that
5587 /// will also compute and cache whether the declaration is externally
5588 /// visible, which might change when we attach the initializer.
5589 ///
5590 /// This can only be used if the declaration is known to not be a
5591 /// redeclaration of an internal linkage declaration.
5592 ///
5593 /// For instance:
5594 ///
5595 /// auto x = []{};
5596 ///
5597 /// Attaching the initializer here makes this declaration not externally
5598 /// visible, because its type has internal linkage.
5599 ///
5600 /// FIXME: This is a hack.
5601 template<typename T>
5602 static bool isIncompleteDeclExternC(Sema &S, const T *D) {
5603  if (S.getLangOpts().CPlusPlus) {
5604  // In C++, the overloadable attribute negates the effects of extern "C".
5605  if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
5606  return false;
5607 
5608  // So do CUDA's host/device attributes if overloading is enabled.
5609  if (S.getLangOpts().CUDA && S.getLangOpts().CUDATargetOverloads &&
5610  (D->template hasAttr<CUDADeviceAttr>() ||
5611  D->template hasAttr<CUDAHostAttr>()))
5612  return false;
5613  }
5614  return D->isExternC();
5615 }
5616 
5617 static bool shouldConsiderLinkage(const VarDecl *VD) {
5618  const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
5619  if (DC->isFunctionOrMethod())
5620  return VD->hasExternalStorage();
5621  if (DC->isFileContext())
5622  return true;
5623  if (DC->isRecord())
5624  return false;
5625  llvm_unreachable("Unexpected context");
5626 }
5627 
5628 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
5629  const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
5630  if (DC->isFileContext() || DC->isFunctionOrMethod())
5631  return true;
5632  if (DC->isRecord())
5633  return false;
5634  llvm_unreachable("Unexpected context");
5635 }
5636 
5637 static bool hasParsedAttr(Scope *S, const AttributeList *AttrList,
5639  for (const AttributeList *L = AttrList; L; L = L->getNext())
5640  if (L->getKind() == Kind)
5641  return true;
5642  return false;
5643 }
5644 
5645 static bool hasParsedAttr(Scope *S, const Declarator &PD,
5647  // Check decl attributes on the DeclSpec.
5649  return true;
5650 
5651  // Walk the declarator structure, checking decl attributes that were in a type
5652  // position to the decl itself.
5653  for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
5654  if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind))
5655  return true;
5656  }
5657 
5658  // Finally, check attributes on the decl itself.
5659  return hasParsedAttr(S, PD.getAttributes(), Kind);
5660 }
5661 
5662 /// Adjust the \c DeclContext for a function or variable that might be a
5663 /// function-local external declaration.
5665  if (!DC->isFunctionOrMethod())
5666  return false;
5667 
5668  // If this is a local extern function or variable declared within a function
5669  // template, don't add it into the enclosing namespace scope until it is
5670  // instantiated; it might have a dependent type right now.
5671  if (DC->isDependentContext())
5672  return true;
5673 
5674  // C++11 [basic.link]p7:
5675  // When a block scope declaration of an entity with linkage is not found to
5676  // refer to some other declaration, then that entity is a member of the
5677  // innermost enclosing namespace.
5678  //
5679  // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
5680  // semantically-enclosing namespace, not a lexically-enclosing one.
5681  while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
5682  DC = DC->getParent();
5683  return true;
5684 }
5685 
5686 /// \brief Returns true if given declaration has external C language linkage.
5687 static bool isDeclExternC(const Decl *D) {
5688  if (const auto *FD = dyn_cast<FunctionDecl>(D))
5689  return FD->isExternC();
5690  if (const auto *VD = dyn_cast<VarDecl>(D))
5691  return VD->isExternC();
5692 
5693  llvm_unreachable("Unknown type of decl!");
5694 }
5695 
5696 NamedDecl *
5699  MultiTemplateParamsArg TemplateParamLists,
5700  bool &AddToScope) {
5701  QualType R = TInfo->getType();
5702  DeclarationName Name = GetNameForDeclarator(D).getName();
5703 
5706 
5707  // dllimport globals without explicit storage class are treated as extern. We
5708  // have to change the storage class this early to get the right DeclContext.
5709  if (SC == SC_None && !DC->isRecord() &&
5710  hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
5711  !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
5712  SC = SC_Extern;
5713 
5714  DeclContext *OriginalDC = DC;
5715  bool IsLocalExternDecl = SC == SC_Extern &&
5716  adjustContextForLocalExternDecl(DC);
5717 
5718  if (getLangOpts().OpenCL) {
5719  // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
5720  QualType NR = R;
5721  while (NR->isPointerType()) {
5722  if (NR->isFunctionPointerType()) {
5723  Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable);
5724  D.setInvalidType();
5725  break;
5726  }
5727  NR = NR->getPointeeType();
5728  }
5729 
5730  if (!getOpenCLOptions().cl_khr_fp16) {
5731  // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
5732  // half array type (unless the cl_khr_fp16 extension is enabled).
5734  Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
5735  D.setInvalidType();
5736  }
5737  }
5738  }
5739 
5740  if (SCSpec == DeclSpec::SCS_mutable) {
5741  // mutable can only appear on non-static class members, so it's always
5742  // an error here
5743  Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
5744  D.setInvalidType();
5745  SC = SC_None;
5746  }
5747 
5748  if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
5749  !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
5751  // In C++11, the 'register' storage class specifier is deprecated.
5752  // Suppress the warning in system macros, it's used in macros in some
5753  // popular C system headers, such as in glibc's htonl() macro.
5755  getLangOpts().CPlusPlus1z ? diag::ext_register_storage_class
5756  : diag::warn_deprecated_register)
5758  }
5759 
5760  IdentifierInfo *II = Name.getAsIdentifierInfo();
5761  if (!II) {
5762  Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
5763  << Name;
5764  return nullptr;
5765  }
5766 
5767  DiagnoseFunctionSpecifiers(D.getDeclSpec());
5768 
5769  if (!DC->isRecord() && S->getFnParent() == nullptr) {
5770  // C99 6.9p2: The storage-class specifiers auto and register shall not
5771  // appear in the declaration specifiers in an external declaration.
5772  // Global Register+Asm is a GNU extension we support.
5773  if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
5774  Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
5775  D.setInvalidType();
5776  }
5777  }
5778 
5779  if (getLangOpts().OpenCL) {
5780  // OpenCL v1.2 s6.9.b p4:
5781  // The sampler type cannot be used with the __local and __global address
5782  // space qualifiers.
5783  if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
5785  Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
5786  }
5787 
5788  // OpenCL 1.2 spec, p6.9 r:
5789  // The event type cannot be used to declare a program scope variable.
5790  // The event type cannot be used with the __local, __constant and __global
5791  // address space qualifiers.
5792  if (R->isEventT()) {
5793  if (S->getParent() == nullptr) {
5794  Diag(D.getLocStart(), diag::err_event_t_global_var);
5795  D.setInvalidType();
5796  }
5797 
5798  if (R.getAddressSpace()) {
5799  Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
5800  D.setInvalidType();
5801  }
5802  }
5803  }
5804 
5805  bool IsExplicitSpecialization = false;
5806  bool IsVariableTemplateSpecialization = false;
5807  bool IsPartialSpecialization = false;
5808  bool IsVariableTemplate = false;
5809  VarDecl *NewVD = nullptr;
5810  VarTemplateDecl *NewTemplate = nullptr;
5811  TemplateParameterList *TemplateParams = nullptr;
5812  if (!getLangOpts().CPlusPlus) {
5813  NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5814  D.getIdentifierLoc(), II,
5815  R, TInfo, SC);
5816 
5817  if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
5818  ParsingInitForAutoVars.insert(NewVD);
5819 
5820  if (D.isInvalidType())
5821  NewVD->setInvalidDecl();
5822  } else {
5823  bool Invalid = false;
5824 
5825  if (DC->isRecord() && !CurContext->isRecord()) {
5826  // This is an out-of-line definition of a static data member.
5827  switch (SC) {
5828  case SC_None:
5829  break;
5830  case SC_Static:
5832  diag::err_static_out_of_line)
5834  break;
5835  case SC_Auto:
5836  case SC_Register:
5837  case SC_Extern:
5838  // [dcl.stc] p2: The auto or register specifiers shall be applied only
5839  // to names of variables declared in a block or to function parameters.
5840  // [dcl.stc] p6: The extern specifier cannot be used in the declaration
5841  // of class members
5842 
5844  diag::err_storage_class_for_static_member)
5846  break;
5847  case SC_PrivateExtern:
5848  llvm_unreachable("C storage class in c++!");
5849  }
5850  }
5851 
5852  if (SC == SC_Static && CurContext->isRecord()) {
5853  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
5854  if (RD->isLocalClass())
5855  Diag(D.getIdentifierLoc(),
5856  diag::err_static_data_member_not_allowed_in_local_class)
5857  << Name << RD->getDeclName();
5858 
5859  // C++98 [class.union]p1: If a union contains a static data member,
5860  // the program is ill-formed. C++11 drops this restriction.
5861  if (RD->isUnion())
5862  Diag(D.getIdentifierLoc(),
5863  getLangOpts().CPlusPlus11
5864  ? diag::warn_cxx98_compat_static_data_member_in_union
5865  : diag::ext_static_data_member_in_union) << Name;
5866  // We conservatively disallow static data members in anonymous structs.
5867  else if (!RD->getDeclName())
5868  Diag(D.getIdentifierLoc(),
5869  diag::err_static_data_member_not_allowed_in_anon_struct)
5870  << Name << RD->isUnion();
5871  }
5872  }
5873 
5874  // Match up the template parameter lists with the scope specifier, then
5875  // determine whether we have a template or a template specialization.
5876  TemplateParams = MatchTemplateParametersToScopeSpecifier(
5878  D.getCXXScopeSpec(),
5880  ? D.getName().TemplateId
5881  : nullptr,
5882  TemplateParamLists,
5883  /*never a friend*/ false, IsExplicitSpecialization, Invalid);
5884 
5885  if (TemplateParams) {
5886  if (!TemplateParams->size() &&
5888  // There is an extraneous 'template<>' for this variable. Complain
5889  // about it, but allow the declaration of the variable.
5890  Diag(TemplateParams->getTemplateLoc(),
5891  diag::err_template_variable_noparams)
5892  << II
5893  << SourceRange(TemplateParams->getTemplateLoc(),
5894  TemplateParams->getRAngleLoc());
5895  TemplateParams = nullptr;
5896  } else {
5898  // This is an explicit specialization or a partial specialization.
5899  // FIXME: Check that we can declare a specialization here.
5900  IsVariableTemplateSpecialization = true;
5901  IsPartialSpecialization = TemplateParams->size() > 0;
5902  } else { // if (TemplateParams->size() > 0)
5903  // This is a template declaration.
5904  IsVariableTemplate = true;
5905 
5906  // Check that we can declare a template here.
5907  if (CheckTemplateDeclScope(S, TemplateParams))
5908  return nullptr;
5909 
5910  // Only C++1y supports variable templates (N3651).
5911  Diag(D.getIdentifierLoc(),
5912  getLangOpts().CPlusPlus14
5913  ? diag::warn_cxx11_compat_variable_template
5914  : diag::ext_variable_template);
5915  }
5916  }
5917  } else {
5918  assert(
5919  (Invalid || D.getName().getKind() != UnqualifiedId::IK_TemplateId) &&
5920  "should have a 'template<>' for this decl");
5921  }
5922 
5923  if (IsVariableTemplateSpecialization) {
5924  SourceLocation TemplateKWLoc =
5925  TemplateParamLists.size() > 0
5926  ? TemplateParamLists[0]->getTemplateLoc()
5927  : SourceLocation();
5928  DeclResult Res = ActOnVarTemplateSpecialization(
5929  S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
5930  IsPartialSpecialization);
5931  if (Res.isInvalid())
5932  return nullptr;
5933  NewVD = cast<VarDecl>(Res.get());
5934  AddToScope = false;
5935  } else
5936  NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5937  D.getIdentifierLoc(), II, R, TInfo, SC);
5938 
5939  // If this is supposed to be a variable template, create it as such.
5940  if (IsVariableTemplate) {
5941  NewTemplate =
5943  TemplateParams, NewVD);
5944  NewVD->setDescribedVarTemplate(NewTemplate);
5945  }
5946 
5947  // If this decl has an auto type in need of deduction, make a note of the
5948  // Decl so we can diagnose uses of it in its own initializer.
5949  if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
5950  ParsingInitForAutoVars.insert(NewVD);
5951 
5952  if (D.isInvalidType() || Invalid) {
5953  NewVD->setInvalidDecl();
5954  if (NewTemplate)
5955  NewTemplate->setInvalidDecl();
5956  }
5957 
5958  SetNestedNameSpecifier(NewVD, D);
5959 
5960  // If we have any template parameter lists that don't directly belong to
5961  // the variable (matching the scope specifier), store them.
5962  unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
5963  if (TemplateParamLists.size() > VDTemplateParamLists)
5965  Context, TemplateParamLists.drop_back(VDTemplateParamLists));
5966 
5968  NewVD->setConstexpr(true);
5969 
5970  if (D.getDeclSpec().isConceptSpecified()) {
5971  NewVD->setConcept(true);
5972 
5973  // C++ Concepts TS [dcl.spec.concept]p2: A concept definition shall not
5974  // be declared with the thread_local, inline, friend, or constexpr
5975  // specifiers, [...]
5978  diag::err_concept_decl_invalid_specifiers)
5979  << 0 << 0;
5980  NewVD->setInvalidDecl(true);
5981  }
5982 
5983  if (D.getDeclSpec().isConstexprSpecified()) {
5985  diag::err_concept_decl_invalid_specifiers)
5986  << 0 << 3;
5987  NewVD->setInvalidDecl(true);
5988  }
5989  }
5990  }
5991 
5992  // Set the lexical context. If the declarator has a C++ scope specifier, the
5993  // lexical context will be different from the semantic context.
5994  NewVD->setLexicalDeclContext(CurContext);
5995  if (NewTemplate)
5996  NewTemplate->setLexicalDeclContext(CurContext);
5997 
5998  if (IsLocalExternDecl)
5999  NewVD->setLocalExternDecl();
6000 
6001  bool EmitTLSUnsupportedError = false;
6003  // C++11 [dcl.stc]p4:
6004  // When thread_local is applied to a variable of block scope the
6005  // storage-class-specifier static is implied if it does not appear
6006  // explicitly.
6007  // Core issue: 'static' is not implied if the variable is declared
6008  // 'extern'.
6009  if (NewVD->hasLocalStorage() &&
6010  (SCSpec != DeclSpec::SCS_unspecified ||
6011  TSCS != DeclSpec::TSCS_thread_local ||
6012  !DC->isFunctionOrMethod()))
6014  diag::err_thread_non_global)
6015  << DeclSpec::getSpecifierName(TSCS);
6016  else if (!Context.getTargetInfo().isTLSSupported()) {
6017  if (getLangOpts().CUDA) {
6018  // Postpone error emission until we've collected attributes required to
6019  // figure out whether it's a host or device variable and whether the
6020  // error should be ignored.
6021  EmitTLSUnsupportedError = true;
6022  // We still need to mark the variable as TLS so it shows up in AST with
6023  // proper storage class for other tools to use even if we're not going
6024  // to emit any code for it.
6025  NewVD->setTSCSpec(TSCS);
6026  } else
6028  diag::err_thread_unsupported);
6029  } else
6030  NewVD->setTSCSpec(TSCS);
6031  }
6032 
6033  // C99 6.7.4p3
6034  // An inline definition of a function with external linkage shall
6035  // not contain a definition of a modifiable object with static or
6036  // thread storage duration...
6037  // We only apply this when the function is required to be defined
6038  // elsewhere, i.e. when the function is not 'extern inline'. Note
6039  // that a local variable with thread storage duration still has to
6040  // be marked 'static'. Also note that it's possible to get these
6041  // semantics in C++ using __attribute__((gnu_inline)).
6042  if (SC == SC_Static && S->getFnParent() != nullptr &&
6043  !NewVD->getType().isConstQualified()) {
6044  FunctionDecl *CurFD = getCurFunctionDecl();
6045  if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
6047  diag::warn_static_local_in_extern_inline);
6048  MaybeSuggestAddingStaticToDecl(CurFD);
6049  }
6050  }
6051 
6053  if (IsVariableTemplateSpecialization)
6054  Diag(NewVD->getLocation(), diag::err_module_private_specialization)
6055  << (IsPartialSpecialization ? 1 : 0)
6058  else if (IsExplicitSpecialization)
6059  Diag(NewVD->getLocation(), diag::err_module_private_specialization)
6060  << 2
6062  else if (NewVD->hasLocalStorage())
6063  Diag(NewVD->getLocation(), diag::err_module_private_local)
6064  << 0 << NewVD->getDeclName()
6067  else {
6068  NewVD->setModulePrivate();
6069  if (NewTemplate)
6070  NewTemplate->setModulePrivate();
6071  }
6072  }
6073 
6074  // Handle attributes prior to checking for duplicates in MergeVarDecl
6075  ProcessDeclAttributes(S, NewVD, D);
6076 
6077  if (getLangOpts().CUDA) {
6078  if (EmitTLSUnsupportedError && DeclAttrsMatchCUDAMode(getLangOpts(), NewVD))
6080  diag::err_thread_unsupported);
6081  // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
6082  // storage [duration]."
6083  if (SC == SC_None && S->getFnParent() != nullptr &&
6084  (NewVD->hasAttr<CUDASharedAttr>() ||
6085  NewVD->hasAttr<CUDAConstantAttr>())) {
6086  NewVD->setStorageClass(SC_Static);
6087  }
6088  }
6089 
6090  // Ensure that dllimport globals without explicit storage class are treated as
6091  // extern. The storage class is set above using parsed attributes. Now we can
6092  // check the VarDecl itself.
6093  assert(!NewVD->hasAttr<DLLImportAttr>() ||
6094  NewVD->getAttr<DLLImportAttr>()->isInherited() ||
6095  NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
6096 
6097  // In auto-retain/release, infer strong retension for variables of
6098  // retainable type.
6099  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
6100  NewVD->setInvalidDecl();
6101 
6102  // Handle GNU asm-label extension (encoded as an attribute).
6103  if (Expr *E = (Expr*)D.getAsmLabel()) {
6104  // The parser guarantees this is a string.
6105  StringLiteral *SE = cast<StringLiteral>(E);
6106  StringRef Label = SE->getString();
6107  if (S->getFnParent() != nullptr) {
6108  switch (SC) {
6109  case SC_None:
6110  case SC_Auto:
6111  Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
6112  break;
6113  case SC_Register:
6114  // Local Named register
6116  DeclAttrsMatchCUDAMode(getLangOpts(), getCurFunctionDecl()))
6117  Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
6118  break;
6119  case SC_Static:
6120  case SC_Extern:
6121  case SC_PrivateExtern:
6122  break;
6123  }
6124  } else if (SC == SC_Register) {
6125  // Global Named register
6126  if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) {
6127  const auto &TI = Context.getTargetInfo();
6128  bool HasSizeMismatch;
6129 
6130  if (!TI.isValidGCCRegisterName(Label))
6131  Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
6132  else if (!TI.validateGlobalRegisterVariable(Label,
6133  Context.getTypeSize(R),
6134  HasSizeMismatch))
6135  Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) << Label;
6136  else if (HasSizeMismatch)
6137  Diag(E->getExprLoc(), diag::err_asm_register_size_mismatch) << Label;
6138  }
6139 
6140  if (!R->isIntegralType(Context) && !R->isPointerType()) {
6141  Diag(D.getLocStart(), diag::err_asm_bad_register_type);
6142  NewVD->setInvalidDecl(true);
6143  }
6144  }
6145 
6146  NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
6147  Context, Label, 0));
6148  } else if (!ExtnameUndeclaredIdentifiers.empty()) {
6150  ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
6151  if (I != ExtnameUndeclaredIdentifiers.end()) {
6152  if (isDeclExternC(NewVD)) {
6153  NewVD->addAttr(I->second);
6154  ExtnameUndeclaredIdentifiers.erase(I);
6155  } else
6156  Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied)
6157  << /*Variable*/1 << NewVD;
6158  }
6159  }
6160 
6161  // Diagnose shadowed variables before filtering for scope.
6162  if (D.getCXXScopeSpec().isEmpty())
6163  CheckShadow(S, NewVD, Previous);
6164 
6165  // Don't consider existing declarations that are in a different
6166  // scope and are out-of-semantic-context declarations (if the new
6167  // declaration has linkage).
6168  FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
6169  D.getCXXScopeSpec().isNotEmpty() ||
6170  IsExplicitSpecialization ||
6171  IsVariableTemplateSpecialization);
6172 
6173  // Check whether the previous declaration is in the same block scope. This
6174  // affects whether we merge types with it, per C++11 [dcl.array]p3.
6175  if (getLangOpts().CPlusPlus &&
6176  NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
6178  Previous.isSingleResult() && !Previous.isShadowed() &&
6179  isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
6180 
6181  if (!getLangOpts().CPlusPlus) {
6182  D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6183  } else {
6184  // If this is an explicit specialization of a static data member, check it.
6185  if (IsExplicitSpecialization && !NewVD->isInvalidDecl() &&
6186  CheckMemberSpecialization(NewVD, Previous))
6187  NewVD->setInvalidDecl();
6188 
6189  // Merge the decl with the existing one if appropriate.
6190  if (!Previous.empty()) {
6191  if (Previous.isSingleResult() &&
6192  isa<FieldDecl>(Previous.getFoundDecl()) &&
6193  D.getCXXScopeSpec().isSet()) {
6194  // The user tried to define a non-static data member
6195  // out-of-line (C++ [dcl.meaning]p1).
6196  Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
6197  << D.getCXXScopeSpec().getRange();
6198  Previous.clear();
6199  NewVD->setInvalidDecl();
6200  }
6201  } else if (D.getCXXScopeSpec().isSet()) {
6202  // No previous declaration in the qualifying scope.
6203  Diag(D.getIdentifierLoc(), diag::err_no_member)
6204  << Name << computeDeclContext(D.getCXXScopeSpec(), true)
6205  << D.getCXXScopeSpec().getRange();
6206  NewVD->setInvalidDecl();
6207  }
6208 
6209  if (!IsVariableTemplateSpecialization)
6210  D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
6211 
6212  if (NewTemplate) {
6213  VarTemplateDecl *PrevVarTemplate =
6214  NewVD->getPreviousDecl()
6216  : nullptr;
6217 
6218  // Check the template parameter list of this declaration, possibly
6219  // merging in the template parameter list from the previous variable
6220  // template declaration.
6221  if (CheckTemplateParameterList(
6222  TemplateParams,
6223  PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
6224  : nullptr,
6225  (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
6226  DC->isDependentContext())
6227  ? TPC_ClassTemplateMember
6228  : TPC_VarTemplate))
6229  NewVD->setInvalidDecl();
6230 
6231  // If we are providing an explicit specialization of a static variable
6232  // template, make a note of that.
6233  if (PrevVarTemplate &&
6234  PrevVarTemplate->getInstantiatedFromMemberTemplate())
6235  PrevVarTemplate->setMemberSpecialization();
6236  }
6237  }
6238 
6239  ProcessPragmaWeak(S, NewVD);
6240 
6241  // If this is the first declaration of an extern C variable, update
6242  // the map of such variables.
6243  if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
6244  isIncompleteDeclExternC(*this, NewVD))
6245  RegisterLocallyScopedExternCDecl(NewVD, S);
6246 
6247  if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
6248  Decl *ManglingContextDecl;
6249  if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext(
6250  NewVD->getDeclContext(), ManglingContextDecl)) {
6252  NewVD, MCtx->getManglingNumber(
6253  NewVD, getMSManglingNumber(getLangOpts(), S)));
6254  Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
6255  }
6256  }
6257 
6258  // Special handling of variable named 'main'.
6259  if (Name.isIdentifier() && Name.getAsIdentifierInfo()->isStr("main") &&
6261  !getLangOpts().Freestanding && !NewVD->getDescribedVarTemplate()) {
6262 
6263  // C++ [basic.start.main]p3
6264  // A program that declares a variable main at global scope is ill-formed.
6265  if (getLangOpts().CPlusPlus)
6266  Diag(D.getLocStart(), diag::err_main_global_variable);
6267 
6268  // In C, and external-linkage variable named main results in undefined
6269  // behavior.
6270  else if (NewVD->hasExternalFormalLinkage())
6271  Diag(D.getLocStart(), diag::warn_main_redefined);
6272  }
6273 
6274  if (D.isRedeclaration() && !Previous.empty()) {
6276  *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD,
6277  IsExplicitSpecialization);
6278  }
6279 
6280  if (NewTemplate) {
6281  if (NewVD->isInvalidDecl())
6282  NewTemplate->setInvalidDecl();
6283  ActOnDocumentableDecl(NewTemplate);
6284  return NewTemplate;
6285  }
6286 
6287  return NewVD;
6288 }
6289 
6290 /// \brief Diagnose variable or built-in function shadowing. Implements
6291 /// -Wshadow.
6292 ///
6293 /// This method is called whenever a VarDecl is added to a "useful"
6294 /// scope.
6295 ///
6296 /// \param S the scope in which the shadowing name is being declared
6297 /// \param R the lookup of the name
6298 ///
6300  // Return if warning is ignored.
6301  if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()))
6302  return;
6303 
6304  // Don't diagnose declarations at file scope.
6305  if (D->hasGlobalStorage())
6306  return;
6307 
6308  DeclContext *NewDC = D->getDeclContext();
6309 
6310  // Only diagnose if we're shadowing an unambiguous field or variable.
6312  return;
6313 
6314  NamedDecl* ShadowedDecl = R.getFoundDecl();
6315  if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
6316  return;
6317 
6318  // Fields are not shadowed by variables in C++ static methods.
6319  if (isa<FieldDecl>(ShadowedDecl))
6320  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
6321  if (MD->isStatic())
6322  return;
6323 
6324  if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
6325  if (shadowedVar->isExternC()) {
6326  // For shadowing external vars, make sure that we point to the global
6327  // declaration, not a locally scoped extern declaration.
6328  for (auto I : shadowedVar->redecls())
6329  if (I->isFileVarDecl()) {
6330  ShadowedDecl = I;
6331  break;
6332  }
6333  }
6334 
6335  DeclContext *OldDC = ShadowedDecl->getDeclContext();
6336 
6337  // Only warn about certain kinds of shadowing for class members.
6338  if (NewDC && NewDC->isRecord()) {
6339  // In particular, don't warn about shadowing non-class members.
6340  if (!OldDC->isRecord())
6341  return;
6342 
6343  // TODO: should we warn about static data members shadowing
6344  // static data members from base classes?
6345 
6346  // TODO: don't diagnose for inaccessible shadowed members.
6347  // This is hard to do perfectly because we might friend the
6348  // shadowing context, but that's just a false negative.
6349  }
6350 
6351  // Determine what kind of declaration we're shadowing.
6352  unsigned Kind;
6353  if (isa<RecordDecl>(OldDC)) {
6354  if (isa<FieldDecl>(ShadowedDecl))
6355  Kind = 3; // field
6356  else
6357  Kind = 2; // static data member
6358  } else if (OldDC->isFileContext())
6359  Kind = 1; // global
6360  else
6361  Kind = 0; // local
6362 
6364 
6365  // Emit warning and note.
6366  if (getSourceManager().isInSystemMacro(R.getNameLoc()))
6367  return;
6368  Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
6369  Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
6370 }
6371 
6372 /// \brief Check -Wshadow without the advantage of a previous lookup.
6374  if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
6375  return;
6376 
6377  LookupResult R(*this, D->getDeclName(), D->getLocation(),
6379  LookupName(R, S);
6380  CheckShadow(S, D, R);
6381 }
6382 
6383 /// Check for conflict between this global or extern "C" declaration and
6384 /// previous global or extern "C" declarations. This is only used in C++.
6385 template<typename T>
6387  Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
6388  assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
6389  NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
6390 
6391  if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
6392  // The common case: this global doesn't conflict with any extern "C"
6393  // declaration.
6394  return false;
6395  }
6396 
6397  if (Prev) {
6398  if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
6399  // Both the old and new declarations have C language linkage. This is a
6400  // redeclaration.
6401  Previous.clear();
6402  Previous.addDecl(Prev);
6403  return true;
6404  }
6405 
6406  // This is a global, non-extern "C" declaration, and there is a previous
6407  // non-global extern "C" declaration. Diagnose if this is a variable
6408  // declaration.
6409  if (!isa<VarDecl>(ND))
6410  return false;
6411  } else {
6412  // The declaration is extern "C". Check for any declaration in the
6413  // translation unit which might conflict.
6414  if (IsGlobal) {
6415  // We have already performed the lookup into the translation unit.
6416  IsGlobal = false;
6417  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6418  I != E; ++I) {
6419  if (isa<VarDecl>(*I)) {
6420  Prev = *I;
6421  break;
6422  }
6423  }
6424  } else {
6426  S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
6427  for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
6428  I != E; ++I) {
6429  if (isa<VarDecl>(*I)) {
6430  Prev = *I;
6431  break;
6432  }
6433  // FIXME: If we have any other entity with this name in global scope,
6434  // the declaration is ill-formed, but that is a defect: it breaks the
6435  // 'stat' hack, for instance. Only variables can have mangled name
6436  // clashes with extern "C" declarations, so only they deserve a
6437  // diagnostic.
6438  }
6439  }
6440 
6441  if (!Prev)
6442  return false;
6443  }
6444 
6445  // Use the first declaration's location to ensure we point at something which
6446  // is lexically inside an extern "C" linkage-spec.
6447  assert(Prev && "should have found a previous declaration to diagnose");
6448  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
6449  Prev = FD->getFirstDecl();
6450  else
6451  Prev = cast<VarDecl>(Prev)->getFirstDecl();
6452 
6453  S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
6454  << IsGlobal << ND;
6455  S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
6456  << IsGlobal;
6457  return false;
6458 }
6459 
6460 /// Apply special rules for handling extern "C" declarations. Returns \c true
6461 /// if we have found that this is a redeclaration of some prior entity.
6462 ///
6463 /// Per C++ [dcl.link]p6:
6464 /// Two declarations [for a function or variable] with C language linkage
6465 /// with the same name that appear in different scopes refer to the same
6466 /// [entity]. An entity with C language linkage shall not be declared with
6467 /// the same name as an entity in global scope.
6468 template<typename T>
6471  if (!S.getLangOpts().CPlusPlus) {
6472  // In C, when declaring a global variable, look for a corresponding 'extern'
6473  // variable declared in function scope. We don't need this in C++, because
6474  // we find local extern decls in the surrounding file-scope DeclContext.
6475  if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
6476  if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
6477  Previous.clear();
6478  Previous.addDecl(Prev);
6479  return true;
6480  }
6481  }
6482  return false;
6483  }
6484 
6485  // A declaration in the translation unit can conflict with an extern "C"
6486  // declaration.
6487  if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
6488  return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
6489 
6490  // An extern "C" declaration can conflict with a declaration in the
6491  // translation unit or can be a redeclaration of an extern "C" declaration
6492  // in another scope.
6493  if (isIncompleteDeclExternC(S,ND))
6494  return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
6495 
6496  // Neither global nor extern "C": nothing to do.
6497  return false;
6498 }
6499 
6501  // If the decl is already known invalid, don't check it.
6502  if (NewVD->isInvalidDecl())
6503  return;
6504 
6505  TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
6506  QualType T = TInfo->getType();
6507 
6508  // Defer checking an 'auto' type until its initializer is attached.
6509  if (T->isUndeducedType())
6510  return;
6511 
6512  if (NewVD->hasAttrs())
6513  CheckAlignasUnderalignment(NewVD);
6514 
6515  if (T->isObjCObjectType()) {
6516  Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
6517  << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
6519  NewVD->setType(T);
6520  }
6521 
6522  // Emit an error if an address space was applied to decl with local storage.
6523  // This includes arrays of objects with address space qualifiers, but not
6524  // automatic variables that point to other address spaces.
6525  // ISO/IEC TR 18037 S5.1.2
6526  if (!getLangOpts().OpenCL
6527  && NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
6528  Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
6529  NewVD->setInvalidDecl();
6530  return;
6531  }
6532 
6533  // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program
6534  // scope.
6535  if (getLangOpts().OpenCLVersion == 120 &&
6536  !getOpenCLOptions().cl_clang_storage_class_specifiers &&
6537  NewVD->isStaticLocal()) {
6538  Diag(NewVD->getLocation(), diag::err_static_function_scope);
6539  NewVD->setInvalidDecl();
6540  return;
6541  }
6542 
6543  // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
6544  // __constant address space.
6545  // OpenCL v2.0 s6.5.1 - Variables defined at program scope and static
6546  // variables inside a function can also be declared in the global
6547  // address space.
6548  if (getLangOpts().OpenCL) {
6549  if (NewVD->isFileVarDecl()) {
6550  if (!T->isSamplerT() &&
6553  getLangOpts().OpenCLVersion == 200))) {
6554  if (getLangOpts().OpenCLVersion == 200)
6555  Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
6556  << "global or constant";
6557  else
6558  Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
6559  << "constant";
6560  NewVD->setInvalidDecl();
6561  return;
6562  }
6563  } else {
6564  // OpenCL v2.0 s6.5.1 - Variables defined at program scope and static
6565  // variables inside a function can also be declared in the global
6566  // address space.
6567  if (NewVD->isStaticLocal() &&
6570  getLangOpts().OpenCLVersion == 200))) {
6571  if (getLangOpts().OpenCLVersion == 200)
6572  Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
6573  << "global or constant";
6574  else
6575  Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
6576  << "constant";
6577  NewVD->setInvalidDecl();
6578  return;
6579  }
6580  // OpenCL v1.1 s6.5.2 and s6.5.3 no local or constant variables
6581  // in functions.
6584  FunctionDecl *FD = getCurFunctionDecl();
6585  if (FD && !FD->hasAttr<OpenCLKernelAttr>()) {
6587  Diag(NewVD->getLocation(), diag::err_opencl_non_kernel_variable)
6588  << "constant";
6589  else
6590  Diag(NewVD->getLocation(), diag::err_opencl_non_kernel_variable)
6591  << "local";
6592  NewVD->setInvalidDecl();
6593  return;
6594  }
6595  }
6596  }
6597  }
6598 
6599  if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
6600  && !NewVD->hasAttr<BlocksAttr>()) {
6601  if (getLangOpts().getGC() != LangOptions::NonGC)
6602  Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
6603  else {
6604  assert(!getLangOpts().ObjCAutoRefCount);
6605  Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
6606  }
6607  }
6608 
6609  bool isVM = T->isVariablyModifiedType();
6610  if (isVM || NewVD->hasAttr<CleanupAttr>() ||
6611  NewVD->hasAttr<BlocksAttr>())
6612  getCurFunction()->setHasBranchProtectedScope();
6613 
6614  if ((isVM && NewVD->hasLinkage()) ||
6615  (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
6616  bool SizeIsNegative;
6617  llvm::APSInt Oversized;
6618  TypeSourceInfo *FixedTInfo =
6620  SizeIsNegative, Oversized);
6621  if (!FixedTInfo && T->isVariableArrayType()) {
6623  // FIXME: This won't give the correct result for
6624  // int a[10][n];
6625  SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
6626 
6627  if (NewVD->isFileVarDecl())
6628  Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
6629  << SizeRange;
6630  else if (NewVD->isStaticLocal())
6631  Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
6632  << SizeRange;
6633  else
6634  Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
6635  << SizeRange;
6636  NewVD->setInvalidDecl();
6637  return;
6638  }
6639 
6640  if (!FixedTInfo) {
6641  if (NewVD->isFileVarDecl())
6642  Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
6643  else
6644  Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
6645  NewVD->setInvalidDecl();
6646  return;
6647  }
6648 
6649  Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
6650  NewVD->setType(FixedTInfo->getType());
6651  NewVD->setTypeSourceInfo(FixedTInfo);
6652  }
6653 
6654  if (T->isVoidType()) {
6655  // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
6656  // of objects and functions.
6657  if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
6658  Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
6659  << T;
6660  NewVD->setInvalidDecl();
6661  return;
6662  }
6663  }
6664 
6665  if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
6666  Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
6667  NewVD->setInvalidDecl();
6668  return;
6669  }
6670 
6671  if (isVM && NewVD->hasAttr<BlocksAttr>()) {
6672  Diag(NewVD->getLocation(), diag::err_block_on_vm);
6673  NewVD->setInvalidDecl();
6674  return;
6675  }
6676 
6677  if (NewVD->isConstexpr() && !T->isDependentType() &&
6678  RequireLiteralType(NewVD->getLocation(), T,
6679  diag::err_constexpr_var_non_literal)) {
6680  NewVD->setInvalidDecl();
6681  return;
6682  }
6683 }
6684 
6685 /// \brief Perform semantic checking on a newly-created variable
6686 /// declaration.
6687 ///
6688 /// This routine performs all of the type-checking required for a
6689 /// variable declaration once it has been built. It is used both to
6690 /// check variables after they have been parsed and their declarators
6691 /// have been translated into a declaration, and to check variables
6692 /// that have been instantiated from a template.
6693 ///
6694 /// Sets NewVD->isInvalidDecl() if an error was encountered.
6695 ///
6696 /// Returns true if the variable declaration is a redeclaration.
6698  CheckVariableDeclarationType(NewVD);
6699 
6700  // If the decl is already known invalid, don't check it.
6701  if (NewVD->isInvalidDecl())
6702  return false;
6703 
6704  // If we did not find anything by this name, look for a non-visible
6705  // extern "C" declaration with the same name.
6706  if (Previous.empty() &&
6707  checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
6708  Previous.setShadowed();
6709 
6710  if (!Previous.empty()) {
6711  MergeVarDecl(NewVD, Previous);
6712  return true;
6713  }
6714  return false;
6715 }
6716 
6717 namespace {
6718 struct FindOverriddenMethod {
6719  Sema *S;
6720  CXXMethodDecl *Method;
6721 
6722  /// Member lookup function that determines whether a given C++
6723  /// method overrides a method in a base class, to be used with
6724  /// CXXRecordDecl::lookupInBases().
6725  bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
6726  RecordDecl *BaseRecord =
6727  Specifier->getType()->getAs<RecordType>()->getDecl();
6728 
6729  DeclarationName Name = Method->getDeclName();
6730 
6731  // FIXME: Do we care about other names here too?
6733  // We really want to find the base class destructor here.
6734  QualType T = S->Context.getTypeDeclType(BaseRecord);
6736 
6738  }
6739 
6740  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
6741  Path.Decls = Path.Decls.slice(1)) {
6742  NamedDecl *D = Path.Decls.front();
6743  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6744  if (MD->isVirtual() && !S->IsOverload(Method, MD, false))
6745  return true;
6746  }
6747  }
6748 
6749  return false;
6750  }
6751 };
6752 
6753 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
6754 } // end anonymous namespace
6755 
6756 /// \brief Report an error regarding overriding, along with any relevant
6757 /// overriden methods.
6758 ///
6759 /// \param DiagID the primary error to report.
6760 /// \param MD the overriding method.
6761 /// \param OEK which overrides to include as notes.
6762 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
6763  OverrideErrorKind OEK = OEK_All) {
6764  S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6766  E = MD->end_overridden_methods();
6767  I != E; ++I) {
6768  // This check (& the OEK parameter) could be replaced by a predicate, but
6769  // without lambdas that would be overkill. This is still nicer than writing
6770  // out the diag loop 3 times.
6771  if ((OEK == OEK_All) ||
6772  (OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
6773  (OEK == OEK_Deleted && (*I)->isDeleted()))
6774  S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
6775  }
6776 }
6777 
6778 /// AddOverriddenMethods - See if a method overrides any in the base classes,
6779 /// and if so, check that it's a valid override and remember it.
6781  // Look for methods in base classes that this method might override.
6782  CXXBasePaths Paths;
6783  FindOverriddenMethod FOM;
6784  FOM.Method = MD;
6785  FOM.S = this;
6786  bool hasDeletedOverridenMethods = false;
6787  bool hasNonDeletedOverridenMethods = false;
6788  bool AddedAny = false;
6789  if (DC->lookupInBases(FOM, Paths)) {
6790  for (auto *I : Paths.found_decls()) {
6791  if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
6792  MD->addOverriddenMethod(OldMD->getCanonicalDecl());
6793  if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
6794  !CheckOverridingFunctionAttributes(MD, OldMD) &&
6795  !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
6796  !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
6797  hasDeletedOverridenMethods |= OldMD->isDeleted();
6798  hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
6799  AddedAny = true;
6800  }
6801  }
6802  }
6803  }
6804 
6805  if (hasDeletedOverridenMethods && !MD->isDeleted()) {
6806  ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
6807  }
6808  if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
6809  ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
6810  }
6811 
6812  return AddedAny;
6813 }
6814 
6815 namespace {
6816  // Struct for holding all of the extra arguments needed by
6817  // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
6818  struct ActOnFDArgs {
6819  Scope *S;
6820  Declarator &D;
6821  MultiTemplateParamsArg TemplateParamLists;
6822  bool AddToScope;
6823  };
6824 }
6825 
6826 namespace {
6827 
6828 // Callback to only accept typo corrections that have a non-zero edit distance.
6829 // Also only accept corrections that have the same parent decl.
6830 class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
6831  public:
6832  DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
6833  CXXRecordDecl *Parent)
6834  : Context(Context), OriginalFD(TypoFD),
6835  ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
6836 
6837  bool ValidateCandidate(const TypoCorrection &candidate) override {
6838  if (candidate.getEditDistance() == 0)
6839  return false;
6840 
6841  SmallVector<unsigned, 1> MismatchedParams;
6842  for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
6843  CDeclEnd = candidate.end();
6844  CDecl != CDeclEnd; ++CDecl) {
6845  FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6846 
6847  if (FD && !FD->hasBody() &&
6848  hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
6849  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
6850  CXXRecordDecl *Parent = MD->getParent();
6851  if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
6852  return true;
6853  } else if (!ExpectedParent) {
6854  return true;
6855  }
6856  }
6857  }
6858 
6859  return false;
6860  }
6861 
6862  private:
6864  FunctionDecl *OriginalFD;
6865  CXXRecordDecl *ExpectedParent;
6866 };
6867 
6868 }
6869 
6870 /// \brief Generate diagnostics for an invalid function redeclaration.
6871 ///
6872 /// This routine handles generating the diagnostic messages for an invalid
6873 /// function redeclaration, including finding possible similar declarations
6874 /// or performing typo correction if there are no previous declarations with
6875 /// the same name.
6876 ///
6877 /// Returns a NamedDecl iff typo correction was performed and substituting in
6878 /// the new declaration name does not cause new errors.
6880  Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
6881  ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
6882  DeclarationName Name = NewFD->getDeclName();
6883  DeclContext *NewDC = NewFD->getDeclContext();
6884  SmallVector<unsigned, 1> MismatchedParams;
6886  TypoCorrection Correction;
6887  bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
6888  unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
6889  : diag::err_member_decl_does_not_match;
6890  LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
6891  IsLocalFriend ? Sema::LookupLocalFriendName
6894 
6895  NewFD->setInvalidDecl();
6896  if (IsLocalFriend)
6897  SemaRef.LookupName(Prev, S);
6898  else
6899  SemaRef.LookupQualifiedName(Prev, NewDC);
6900  assert(!Prev.isAmbiguous() &&
6901  "Cannot have an ambiguity in previous-declaration lookup");
6902  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
6903  if (!Prev.empty()) {
6904  for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
6905  Func != FuncEnd; ++Func) {
6906  FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
6907  if (FD &&
6908  hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
6909  // Add 1 to the index so that 0 can mean the mismatch didn't
6910  // involve a parameter
6911  unsigned ParamNum =
6912  MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
6913  NearMatches.push_back(std::make_pair(FD, ParamNum));
6914  }
6915  }
6916  // If the qualified name lookup yielded nothing, try typo correction
6917  } else if ((Correction = SemaRef.CorrectTypo(
6918  Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
6919  &ExtraArgs.D.getCXXScopeSpec(),
6920  llvm::make_unique<DifferentNameValidatorCCC>(
6921  SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr),
6922  Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
6923  // Set up everything for the call to ActOnFunctionDeclarator
6924  ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
6925  ExtraArgs.D.getIdentifierLoc());
6926  Previous.clear();
6927  Previous.setLookupName(Correction.getCorrection());
6928  for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
6929  CDeclEnd = Correction.end();
6930  CDecl != CDeclEnd; ++CDecl) {
6931  FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6932  if (FD && !FD->hasBody() &&
6933  hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
6934  Previous.addDecl(FD);
6935  }
6936  }
6937  bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
6938 
6939  NamedDecl *Result;
6940  // Retry building the function declaration with the new previous
6941  // declarations, and with errors suppressed.
6942  {
6943  // Trap errors.
6944  Sema::SFINAETrap Trap(SemaRef);
6945 
6946  // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
6947  // pieces need to verify the typo-corrected C++ declaration and hopefully
6948  // eliminate the need for the parameter pack ExtraArgs.
6949  Result = SemaRef.ActOnFunctionDeclarator(
6950  ExtraArgs.S, ExtraArgs.D,
6951  Correction.getCorrectionDecl()->getDeclContext(),
6952  NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
6953  ExtraArgs.AddToScope);
6954 
6955  if (Trap.hasErrorOccurred())
6956  Result = nullptr;
6957  }
6958 
6959  if (Result) {
6960  // Determine which correction we picked.
6961  Decl *Canonical = Result->getCanonicalDecl();
6962  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6963  I != E; ++I)
6964  if ((*I)->getCanonicalDecl() == Canonical)
6965  Correction.setCorrectionDecl(*I);
6966 
6967  SemaRef.diagnoseTypo(
6968  Correction,
6969  SemaRef.PDiag(IsLocalFriend
6970  ? diag::err_no_matching_local_friend_suggest
6971  : diag::err_member_decl_does_not_match_suggest)
6972  << Name << NewDC << IsDefinition);
6973  return Result;
6974  }
6975 
6976  // Pretend the typo correction never occurred
6977  ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
6978  ExtraArgs.D.getIdentifierLoc());
6979  ExtraArgs.D.setRedeclaration(wasRedeclaration);
6980  Previous.clear();
6981  Previous.setLookupName(Name);
6982  }
6983 
6984  SemaRef.Diag(NewFD->getLocation(), DiagMsg)
6985  << Name << NewDC << IsDefinition << NewFD->getLocation();
6986 
6987  bool NewFDisConst = false;
6988  if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
6989  NewFDisConst = NewMD->isConst();
6990 
6991  for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
6992  NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
6993  NearMatch != NearMatchEnd; ++NearMatch) {
6994  FunctionDecl *FD = NearMatch->first;
6995  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
6996  bool FDisConst = MD && MD->isConst();
6997  bool IsMember = MD || !IsLocalFriend;
6998 
6999  // FIXME: These notes are poorly worded for the local friend case.
7000  if (unsigned Idx = NearMatch->second) {
7001  ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
7002  SourceLocation Loc = FDParam->getTypeSpecStartLoc();
7003  if (Loc.isInvalid()) Loc = FD->getLocation();
7004  SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
7005  : diag::note_local_decl_close_param_match)
7006  << Idx << FDParam->getType()
7007  << NewFD->getParamDecl(Idx - 1)->getType();
7008  } else if (FDisConst != NewFDisConst) {
7009  SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
7010  << NewFDisConst << FD->getSourceRange().getEnd();
7011  } else
7012  SemaRef.Diag(FD->getLocation(),
7013  IsMember ? diag::note_member_def_close_match
7014  : diag::note_local_decl_close_match);
7015  }
7016  return nullptr;
7017 }
7018 
7020  switch (D.getDeclSpec().getStorageClassSpec()) {
7021  default: llvm_unreachable("Unknown storage class!");
7022  case DeclSpec::SCS_auto:
7024  case DeclSpec::SCS_mutable:
7025  SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7026  diag::err_typecheck_sclass_func);
7027  D.setInvalidType();
7028  break;
7029  case DeclSpec::SCS_unspecified: break;
7030  case DeclSpec::SCS_extern:
7032  return SC_None;
7033  return SC_Extern;
7034  case DeclSpec::SCS_static: {
7035  if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
7036  // C99 6.7.1p5:
7037  // The declaration of an identifier for a function that has
7038  // block scope shall have no explicit storage-class specifier
7039  // other than extern
7040  // See also (C++ [dcl.stc]p4).
7041  SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7042  diag::err_static_block_func);
7043  break;
7044  } else
7045  return SC_Static;
7046  }
7048  }
7049 
7050  // No explicit storage class has already been returned
7051  return SC_None;
7052 }
7053 
7055  DeclContext *DC, QualType &R,
7056  TypeSourceInfo *TInfo,
7057  StorageClass SC,
7058  bool &IsVirtualOkay) {
7059  DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
7060  DeclarationName Name = NameInfo.getName();
7061 
7062  FunctionDecl *NewFD = nullptr;
7063  bool isInline = D.getDeclSpec().isInlineSpecified();
7064 
7065  if (!SemaRef.getLangOpts().CPlusPlus) {
7066  // Determine whether the function was written with a
7067  // prototype. This true when:
7068  // - there is a prototype in the declarator, or
7069  // - the type R of the function is some kind of typedef or other reference
7070  // to a type name (which eventually refers to a function type).
7071  bool HasPrototype =
7073  (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
7074 
7075  NewFD = FunctionDecl::Create(SemaRef.Context, DC,
7076  D.getLocStart(), NameInfo, R,
7077  TInfo, SC, isInline,
7078  HasPrototype, false);
7079  if (D.isInvalidType())
7080  NewFD->setInvalidDecl();
7081 
7082  return NewFD;
7083  }
7084 
7085  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
7086  bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
7087 
7088  // Check that the return type is not an abstract class type.
7089  // For record types, this is done by the AbstractClassUsageDiagnoser once
7090  // the class has been completely parsed.
7091  if (!DC->isRecord() &&
7092  SemaRef.RequireNonAbstractType(
7093  D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
7094  diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
7095  D.setInvalidType();
7096 
7098  // This is a C++ constructor declaration.
7099  assert(DC->isRecord() &&
7100  "Constructors can only be declared in a member context");
7101 
7102  R = SemaRef.CheckConstructorDeclarator(D, R, SC);
7103  return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
7104  D.getLocStart(), NameInfo,
7105  R, TInfo, isExplicit, isInline,
7106  /*isImplicitlyDeclared=*/false,
7107  isConstexpr);
7108 
7109  } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7110  // This is a C++ destructor declaration.
7111  if (DC->isRecord()) {
7112  R = SemaRef.CheckDestructorDeclarator(D, R, SC);
7113  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
7115  SemaRef.Context, Record,
7116  D.getLocStart(),
7117  NameInfo, R, TInfo, isInline,
7118  /*isImplicitlyDeclared=*/false);
7119 
7120  // If the class is complete, then we now create the implicit exception
7121  // specification. If the class is incomplete or dependent, we can't do
7122  // it yet.
7123  if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
7124  Record->getDefinition() && !Record->isBeingDefined() &&
7125  R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
7126  SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
7127  }
7128 
7129  IsVirtualOkay = true;
7130  return NewDD;
7131 
7132  } else {
7133  SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
7134  D.setInvalidType();
7135 
7136  // Create a FunctionDecl to satisfy the function definition parsing
7137  // code path.
7138  return FunctionDecl::Create(SemaRef.Context, DC,
7139  D.getLocStart(),
7140  D.getIdentifierLoc(), Name, R, TInfo,
7141  SC, isInline,
7142  /*hasPrototype=*/true, isConstexpr);
7143  }
7144 
7146  if (!DC->isRecord()) {
7147  SemaRef.Diag(D.getIdentifierLoc(),
7148  diag::err_conv_function_not_member);
7149  return nullptr;
7150  }
7151 
7152  SemaRef.CheckConversionDeclarator(D, R, SC);
7153  IsVirtualOkay = true;
7154  return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
7155  D.getLocStart(), NameInfo,
7156  R, TInfo, isInline, isExplicit,
7157  isConstexpr, SourceLocation());
7158 
7159  } else if (DC->isRecord()) {
7160  // If the name of the function is the same as the name of the record,
7161  // then this must be an invalid constructor that has a return type.
7162  // (The parser checks for a return type and makes the declarator a
7163  // constructor if it has no return type).
7164  if (Name.getAsIdentifierInfo() &&
7165  Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
7166  SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
7168  << SourceRange(D.getIdentifierLoc());
7169  return nullptr;
7170  }
7171 
7172  // This is a C++ method declaration.
7174  cast<CXXRecordDecl>(DC),
7175  D.getLocStart(), NameInfo, R,
7176  TInfo, SC, isInline,
7177  isConstexpr, SourceLocation());
7178  IsVirtualOkay = !Ret->isStatic();
7179  return Ret;
7180  } else {
7181  bool isFriend =
7182  SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
7183  if (!isFriend && SemaRef.CurContext->isRecord())
7184  return nullptr;
7185 
7186  // Determine whether the function was written with a
7187  // prototype. This true when:
7188  // - we're in C++ (where every function has a prototype),
7189  return FunctionDecl::Create(SemaRef.Context, DC,
7190  D.getLocStart(),
7191  NameInfo, R, TInfo, SC, isInline,
7192  true/*HasPrototype*/, isConstexpr);
7193  }
7194 }
7195 
7203 };
7204 
7206  if (PT->isPointerType()) {
7207  QualType PointeeType = PT->getPointeeType();
7208  if (PointeeType->isPointerType())
7209  return PtrPtrKernelParam;
7210  return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
7211  : PtrKernelParam;
7212  }
7213 
7214  // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
7215  // be used as builtin types.
7216 
7217  if (PT->isImageType())
7218  return PtrKernelParam;
7219 
7220  if (PT->isBooleanType())
7221  return InvalidKernelParam;
7222 
7223  if (PT->isEventT())
7224  return InvalidKernelParam;
7225 
7226  if (PT->isHalfType())
7227  return InvalidKernelParam;
7228 
7229  if (PT->isRecordType())
7230  return RecordKernelParam;
7231 
7232  return ValidKernelParam;
7233 }
7234 
7236  Sema &S,
7237  Declarator &D,
7238  ParmVarDecl *Param,
7239  llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
7240  QualType PT = Param->getType();
7241 
7242  // Cache the valid types we encounter to avoid rechecking structs that are
7243  // used again
7244  if (ValidTypes.count(PT.getTypePtr()))
7245  return;
7246 
7247  switch (getOpenCLKernelParameterType(PT)) {
7248  case PtrPtrKernelParam:
7249  // OpenCL v1.2 s6.9.a:
7250  // A kernel function argument cannot be declared as a
7251  // pointer to a pointer type.
7252  S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
7253  D.setInvalidType();
7254  return;
7255 
7256  case PrivatePtrKernelParam:
7257  // OpenCL v1.2 s6.9.a:
7258  // A kernel function argument cannot be declared as a
7259  // pointer to the private address space.
7260  S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
7261  D.setInvalidType();
7262  return;
7263 
7264  // OpenCL v1.2 s6.9.k:
7265  // Arguments to kernel functions in a program cannot be declared with the
7266  // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
7267  // uintptr_t or a struct and/or union that contain fields declared to be
7268  // one of these built-in scalar types.
7269 
7270  case InvalidKernelParam:
7271  // OpenCL v1.2 s6.8 n:
7272  // A kernel function argument cannot be declared
7273  // of event_t type.
7274  S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7275  D.setInvalidType();
7276  return;
7277 
7278  case PtrKernelParam:
7279  case ValidKernelParam:
7280  ValidTypes.insert(PT.getTypePtr());
7281  return;
7282 
7283  case RecordKernelParam:
7284  break;
7285  }
7286 
7287  // Track nested structs we will inspect
7288  SmallVector<const Decl *, 4> VisitStack;
7289 
7290  // Track where we are in the nested structs. Items will migrate from
7291  // VisitStack to HistoryStack as we do the DFS for bad field.
7292  SmallVector<const FieldDecl *, 4> HistoryStack;
7293  HistoryStack.push_back(nullptr);
7294 
7295  const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
7296  VisitStack.push_back(PD);
7297 
7298  assert(VisitStack.back() && "First decl null?");
7299 
7300  do {
7301  const Decl *Next = VisitStack.pop_back_val();
7302  if (!Next) {
7303  assert(!HistoryStack.empty());
7304  // Found a marker, we have gone up a level
7305  if (const FieldDecl *Hist = HistoryStack.pop_back_val())
7306  ValidTypes.insert(Hist->getType().getTypePtr());
7307 
7308  continue;
7309  }
7310 
7311  // Adds everything except the original parameter declaration (which is not a
7312  // field itself) to the history stack.
7313  const RecordDecl *RD;
7314  if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
7315  HistoryStack.push_back(Field);
7316  RD = Field->getType()->castAs<RecordType>()->getDecl();
7317  } else {
7318  RD = cast<RecordDecl>(Next);
7319  }
7320 
7321  // Add a null marker so we know when we've gone back up a level
7322  VisitStack.push_back(nullptr);
7323 
7324  for (const auto *FD : RD->fields()) {
7325  QualType QT = FD->getType();
7326 
7327  if (ValidTypes.count(QT.getTypePtr()))
7328  continue;
7329 
7331  if (ParamType == ValidKernelParam)
7332  continue;
7333 
7334  if (ParamType == RecordKernelParam) {
7335  VisitStack.push_back(FD);
7336  continue;
7337  }
7338 
7339  // OpenCL v1.2 s6.9.p:
7340  // Arguments to kernel functions that are declared to be a struct or union
7341  // do not allow OpenCL objects to be passed as elements of the struct or
7342  // union.
7343  if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
7344  ParamType == PrivatePtrKernelParam) {
7345  S.Diag(Param->getLocation(),
7346  diag::err_record_with_pointers_kernel_param)
7347  << PT->isUnionType()
7348  << PT;
7349  } else {
7350  S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
7351  }
7352 
7353  S.Diag(PD->getLocation(), diag::note_within_field_of_type)
7354  << PD->getDeclName();
7355 
7356  // We have an error, now let's go back up through history and show where
7357  // the offending field came from
7359  I = HistoryStack.begin() + 1,
7360  E = HistoryStack.end();
7361  I != E; ++I) {
7362  const FieldDecl *OuterField = *I;
7363  S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
7364  << OuterField->getType();
7365  }
7366 
7367  S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
7368  << QT->isPointerType()
7369  << QT;
7370  D.setInvalidType();
7371  return;
7372  }
7373  } while (!VisitStack.empty());
7374 }
7375 
7376 NamedDecl*
7379  MultiTemplateParamsArg TemplateParamLists,
7380  bool &AddToScope) {
7381  QualType R = TInfo->getType();
7382 
7383  assert(R.getTypePtr()->isFunctionType());
7384 
7385  // TODO: consider using NameInfo for diagnostic.
7386  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
7387  DeclarationName Name = NameInfo.getName();
7388  StorageClass SC = getFunctionStorageClass(*this, D);
7389 
7392  diag::err_invalid_thread)
7393  << DeclSpec::getSpecifierName(TSCS);
7394 
7396  adjustMemberFunctionCC(R, D.isStaticMember(), D.isCtorOrDtor(),
7397  D.getIdentifierLoc());
7398 
7399  bool isFriend = false;
7400  FunctionTemplateDecl *FunctionTemplate = nullptr;
7401  bool isExplicitSpecialization = false;
7402  bool isFunctionTemplateSpecialization = false;
7403 
7404  bool isDependentClassScopeExplicitSpecialization = false;
7405  bool HasExplicitTemplateArgs = false;
7406  TemplateArgumentListInfo TemplateArgs;
7407 
7408  bool isVirtualOkay = false;
7409 
7410  DeclContext *OriginalDC = DC;
7411  bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
7412 
7413  FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
7414  isVirtualOkay);
7415  if (!NewFD) return nullptr;
7416 
7417  if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
7419 
7420  // Set the lexical context. If this is a function-scope declaration, or has a
7421  // C++ scope specifier, or is the object of a friend declaration, the lexical
7422  // context will be different from the semantic context.
7423  NewFD->setLexicalDeclContext(CurContext);
7424 
7425  if (IsLocalExternDecl)
7426  NewFD->setLocalExternDecl();
7427 
7428  if (getLangOpts().CPlusPlus) {
7429  bool isInline = D.getDeclSpec().isInlineSpecified();
7430  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
7431  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
7432  bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
7433  bool isConcept = D.getDeclSpec().isConceptSpecified();
7434  isFriend = D.getDeclSpec().isFriendSpecified();
7435  if (isFriend && !isInline && D.isFunctionDefinition()) {
7436  // C++ [class.friend]p5
7437  // A function can be defined in a friend declaration of a
7438  // class . . . . Such a function is implicitly inline.
7439  NewFD->setImplicitlyInline();
7440  }
7441 
7442  // If this is a method defined in an __interface, and is not a constructor
7443  // or an overloaded operator, then set the pure flag (isVirtual will already
7444  // return true).
7445  if (const CXXRecordDecl *Parent =
7446  dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
7447  if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
7448  NewFD->setPure(true);
7449 
7450  // C++ [class.union]p2
7451  // A union can have member functions, but not virtual functions.
7452  if (isVirtual && Parent->isUnion())
7453  Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);
7454  }
7455 
7456  SetNestedNameSpecifier(NewFD, D);
7457  isExplicitSpecialization = false;
7458  isFunctionTemplateSpecialization = false;
7459  if (D.isInvalidType())
7460  NewFD->setInvalidDecl();
7461 
7462  // Match up the template parameter lists with the scope specifier, then
7463  // determine whether we have a template or a template specialization.
7464  bool Invalid = false;
7465  if (TemplateParameterList *TemplateParams =
7466  MatchTemplateParametersToScopeSpecifier(
7468  D.getCXXScopeSpec(),
7470  ? D.getName().TemplateId
7471  : nullptr,
7472  TemplateParamLists, isFriend, isExplicitSpecialization,
7473  Invalid)) {
7474  if (TemplateParams->size() > 0) {
7475  // This is a function template
7476 
7477  // Check that we can declare a template here.
7478  if (CheckTemplateDeclScope(S, TemplateParams))
7479  NewFD->setInvalidDecl();
7480 
7481  // A destructor cannot be a template.
7483  Diag(NewFD->getLocation(), diag::err_destructor_template);
7484  NewFD->setInvalidDecl();
7485  }
7486 
7487  // If we're adding a template to a dependent context, we may need to
7488  // rebuilding some of the types used within the template parameter list,
7489  // now that we know what the current instantiation is.
7490  if (DC->isDependentContext()) {
7491  ContextRAII SavedContext(*this, DC);
7492  if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
7493  Invalid = true;
7494  }
7495 
7496 
7497  FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
7498  NewFD->getLocation(),
7499  Name, TemplateParams,
7500  NewFD);
7501  FunctionTemplate->setLexicalDeclContext(CurContext);
7502  NewFD->setDescribedFunctionTemplate(FunctionTemplate);
7503 
7504  // For source fidelity, store the other template param lists.
7505  if (TemplateParamLists.size() > 1) {
7507  TemplateParamLists.drop_back(1));
7508  }
7509  } else {
7510  // This is a function template specialization.
7511  isFunctionTemplateSpecialization = true;
7512  // For source fidelity, store all the template param lists.
7513  if (TemplateParamLists.size() > 0)
7514  NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
7515 
7516  // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
7517  if (isFriend) {
7518  // We want to remove the "template<>", found here.
7519  SourceRange RemoveRange = TemplateParams->getSourceRange();
7520 
7521  // If we remove the template<> and the name is not a
7522  // template-id, we're actually silently creating a problem:
7523  // the friend declaration will refer to an untemplated decl,
7524  // and clearly the user wants a template specialization. So
7525  // we need to insert '<>' after the name.
7526  SourceLocation InsertLoc;
7528  InsertLoc = D.getName().getSourceRange().getEnd();
7529  InsertLoc = getLocForEndOfToken(InsertLoc);
7530  }
7531 
7532  Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
7533  << Name << RemoveRange
7534  << FixItHint::CreateRemoval(RemoveRange)
7535  << FixItHint::CreateInsertion(InsertLoc, "<>");
7536  }
7537  }
7538  }
7539  else {
7540  // All template param lists were matched against the scope specifier:
7541  // this is NOT (an explicit specialization of) a template.
7542  if (TemplateParamLists.size() > 0)
7543  // For source fidelity, store all the template param lists.
7544  NewFD->setTemplateParameterListsInfo(Context, TemplateParamLists);
7545  }
7546 
7547  if (Invalid) {
7548  NewFD->setInvalidDecl();
7549  if (FunctionTemplate)
7550  FunctionTemplate->setInvalidDecl();
7551  }
7552 
7553  // C++ [dcl.fct.spec]p5:
7554  // The virtual specifier shall only be used in declarations of
7555  // nonstatic class member functions that appear within a
7556  // member-specification of a class declaration; see 10.3.
7557  //
7558  if (isVirtual && !NewFD->isInvalidDecl()) {
7559  if (!isVirtualOkay) {
7561  diag::err_virtual_non_function);
7562  } else if (!CurContext->isRecord()) {
7563  // 'virtual' was specified outside of the class.
7565  diag::err_virtual_out_of_class)
7567  } else if (NewFD->getDescribedFunctionTemplate()) {
7568  // C++ [temp.mem]p3:
7569  // A member function template shall not be virtual.
7571  diag::err_virtual_member_function_template)
7573  } else {
7574  // Okay: Add virtual to the method.
7575  NewFD->setVirtualAsWritten(true);
7576  }
7577 
7578  if (getLangOpts().CPlusPlus14 &&
7579  NewFD->getReturnType()->isUndeducedType())
7580  Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
7581  }
7582 
7583  if (getLangOpts().CPlusPlus14 &&
7584  (NewFD->isDependentContext() ||
7585  (isFriend && CurContext->isDependentContext())) &&
7586  NewFD->getReturnType()->isUndeducedType()) {
7587  // If the function template is referenced directly (for instance, as a
7588  // member of the current instantiation), pretend it has a dependent type.
7589  // This is not really justified by the standard, but is the only sane
7590  // thing to do.
7591  // FIXME: For a friend function, we have not marked the function as being
7592  // a friend yet, so 'isDependentContext' on the FD doesn't work.
7593  const FunctionProtoType *FPT =
7594  NewFD->getType()->castAs<FunctionProtoType>();
7595  QualType Result =
7596  SubstAutoType(FPT->getReturnType(), Context.DependentTy);
7597  NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
7598  FPT->getExtProtoInfo()));
7599  }
7600 
7601  // C++ [dcl.fct.spec]p3:
7602  // The inline specifier shall not appear on a block scope function
7603  // declaration.
7604  if (isInline && !NewFD->isInvalidDecl()) {
7605  if (CurContext->isFunctionOrMethod()) {
7606  // 'inline' is not allowed on block scope function declaration.
7608  diag::err_inline_declaration_block_scope) << Name
7610  }
7611  }
7612 
7613  // C++ [dcl.fct.spec]p6:
7614  // The explicit specifier shall be used only in the declaration of a
7615  // constructor or conversion function within its class definition;
7616  // see 12.3.1 and 12.3.2.
7617  if (isExplicit && !NewFD->isInvalidDecl()) {
7618  if (!CurContext->isRecord()) {
7619  // 'explicit' was specified outside of the class.
7621  diag::err_explicit_out_of_class)
7623  } else if (!isa<CXXConstructorDecl>(NewFD) &&
7624  !isa<CXXConversionDecl>(NewFD)) {
7625  // 'explicit' was specified on a function that wasn't a constructor
7626  // or conversion function.
7628  diag::err_explicit_non_ctor_or_conv_function)
7630  }
7631  }
7632 
7633  if (isConstexpr) {
7634  // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
7635  // are implicitly inline.
7636  NewFD->setImplicitlyInline();
7637 
7638  // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
7639  // be either constructors or to return a literal type. Therefore,
7640  // destructors cannot be declared constexpr.
7641  if (isa<CXXDestructorDecl>(NewFD))
7642  Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
7643  }
7644 
7645  if (isConcept) {
7646  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
7647  // applied only to the definition of a function template [...]
7648  if (!D.isFunctionDefinition()) {
7650  diag::err_function_concept_not_defined);
7651  NewFD->setInvalidDecl();
7652  }
7653 
7654  // C++ Concepts TS [dcl.spec.concept]p1: [...] A function concept shall
7655  // have no exception-specification and is treated as if it were specified
7656  // with noexcept(true) (15.4). [...]
7657  if (const FunctionProtoType *FPT = R->getAs<FunctionProtoType>()) {
7658  if (FPT->hasExceptionSpec()) {
7659  SourceRange Range;
7660  if (D.isFunctionDeclarator())
7662  Diag(NewFD->getLocation(), diag::err_function_concept_exception_spec)
7663  << FixItHint::CreateRemoval(Range);
7664  NewFD->setInvalidDecl();
7665  } else {
7667  }
7668 
7669  // C++ Concepts TS [dcl.spec.concept]p5: A function concept has the
7670  // following restrictions:
7671  // - The declaration's parameter list shall be equivalent to an empty
7672  // parameter list.
7673  if (FPT->getNumParams() > 0 || FPT->isVariadic())
7674  Diag(NewFD->getLocation(), diag::err_function_concept_with_params);
7675  }
7676 
7677  // C++ Concepts TS [dcl.spec.concept]p2: Every concept definition is
7678  // implicity defined to be a constexpr declaration (implicitly inline)
7679  NewFD->setImplicitlyInline();
7680 
7681  // C++ Concepts TS [dcl.spec.concept]p2: A concept definition shall not
7682  // be declared with the thread_local, inline, friend, or constexpr
7683  // specifiers, [...]
7684  if (isInline) {
7686  diag::err_concept_decl_invalid_specifiers)
7687  << 1 << 1;
7688  NewFD->setInvalidDecl(true);
7689  }
7690 
7691  if (isFriend) {
7693  diag::err_concept_decl_invalid_specifiers)
7694  << 1 << 2;
7695  NewFD->setInvalidDecl(true);
7696  }
7697 
7698  if (isConstexpr) {
7700  diag::err_concept_decl_invalid_specifiers)
7701  << 1 << 3;
7702  NewFD->setInvalidDecl(true);
7703  }
7704  }
7705 
7706  // If __module_private__ was specified, mark the function accordingly.
7708  if (isFunctionTemplateSpecialization) {
7709  SourceLocation ModulePrivateLoc
7711  Diag(ModulePrivateLoc, diag::err_module_private_specialization)
7712  << 0
7713  << FixItHint::CreateRemoval(ModulePrivateLoc);
7714  } else {
7715  NewFD->setModulePrivate();
7716  if (FunctionTemplate)
7717  FunctionTemplate->setModulePrivate();
7718  }
7719  }
7720 
7721  if (isFriend) {
7722  if (FunctionTemplate) {
7723  FunctionTemplate->setObjectOfFriendDecl();
7724  FunctionTemplate->setAccess(AS_public);
7725  }
7726  NewFD->setObjectOfFriendDecl();
7727  NewFD->setAccess(AS_public);
7728  }
7729 
7730  // If a function is defined as defaulted or deleted, mark it as such now.
7731  // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
7732  // definition kind to FDK_Definition.
7733  switch (D.getFunctionDefinitionKind()) {
7734  case FDK_Declaration:
7735  case FDK_Definition:
7736  break;
7737 
7738  case FDK_Defaulted:
7739  NewFD->setDefaulted();
7740  break;
7741 
7742  case FDK_Deleted:
7743  NewFD->setDeletedAsWritten();
7744  break;
7745  }
7746 
7747  if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
7748  D.isFunctionDefinition()) {
7749  // C++ [class.mfct]p2:
7750  // A member function may be defined (8.4) in its class definition, in
7751  // which case it is an inline member function (7.1.2)
7752  NewFD->setImplicitlyInline();
7753  }
7754 
7755  if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
7756  !CurContext->isRecord()) {
7757  // C++ [class.static]p1:
7758  // A data or function member of a class may be declared static
7759  // in a class definition, in which case it is a static member of
7760  // the class.
7761 
7762  // Complain about the 'static' specifier if it's on an out-of-line
7763  // member function definition.
7765  diag::err_static_out_of_line)
7767  }
7768 
7769  // C++11 [except.spec]p15:
7770  // A deallocation function with no exception-specification is treated
7771  // as if it were specified with noexcept(true).
7772  const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
7773  if ((Name.getCXXOverloadedOperator() == OO_Delete ||
7774  Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
7775  getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
7777  FPT->getReturnType(), FPT->getParamTypes(),
7779  }
7780 
7781  // Filter out previous declarations that don't match the scope.
7782  FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
7783  D.getCXXScopeSpec().isNotEmpty() ||
7784  isExplicitSpecialization ||
7785  isFunctionTemplateSpecialization);
7786 
7787  // Handle GNU asm-label extension (encoded as an attribute).
7788  if (Expr *E = (Expr*) D.getAsmLabel()) {
7789  // The parser guarantees this is a string.
7790  StringLiteral *SE = cast<StringLiteral>(E);
7791  NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
7792  SE->getString(), 0));
7793  } else if (!ExtnameUndeclaredIdentifiers.empty()) {
7795  ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
7796  if (I != ExtnameUndeclaredIdentifiers.end()) {
7797  if (isDeclExternC(NewFD)) {
7798  NewFD->addAttr(I->second);
7799  ExtnameUndeclaredIdentifiers.erase(I);
7800  } else
7801  Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied)
7802  << /*Variable*/0 << NewFD;
7803  }
7804  }
7805 
7806  // Copy the parameter declarations from the declarator D to the function
7807  // declaration NewFD, if they are available. First scavenge them into Params.
7809  if (D.isFunctionDeclarator()) {
7811 
7812  // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
7813  // function that takes no arguments, not a function that takes a
7814  // single void argument.
7815  // We let through "const void" here because Sema::GetTypeForDeclarator
7816  // already checks for that case.
7817  if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
7818  for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
7819  ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
7820  assert(Param->getDeclContext() != NewFD && "Was set before ?");
7821  Param->setDeclContext(NewFD);
7822  Params.push_back(Param);
7823 
7824  if (Param->isInvalidDecl())
7825  NewFD->setInvalidDecl();
7826  }
7827  }
7828 
7829  } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
7830  // When we're declaring a function with a typedef, typeof, etc as in the
7831  // following example, we'll need to synthesize (unnamed)
7832  // parameters for use in the declaration.
7833  //
7834  // @code
7835  // typedef void fn(int);
7836  // fn f;
7837  // @endcode
7838 
7839  // Synthesize a parameter for each argument type.
7840  for (const auto &AI : FT->param_types()) {
7841  ParmVarDecl *Param =
7842  BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
7843  Param->setScopeInfo(0, Params.size());
7844  Params.push_back(Param);
7845  }
7846  } else {
7847  assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
7848  "Should not need args for typedef of non-prototype fn");
7849  }
7850 
7851  // Finally, we know we have the right number of parameters, install them.
7852  NewFD->setParams(Params);
7853 
7854  // Find all anonymous symbols defined during the declaration of this function
7855  // and add to NewFD. This lets us track decls such 'enum Y' in:
7856  //
7857  // void f(enum Y {AA} x) {}
7858  //
7859  // which would otherwise incorrectly end up in the translation unit scope.
7860  NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
7861  DeclsInPrototypeScope.clear();
7862 
7863  if (D.getDeclSpec().isNoreturnSpecified())
7864  NewFD->addAttr(
7865  ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
7866  Context, 0));
7867 
7868  // Functions returning a variably modified type violate C99 6.7.5.2p2
7869  // because all functions have linkage.
7870  if (!NewFD->isInvalidDecl() &&
7871  NewFD->getReturnType()->isVariablyModifiedType()) {
7872  Diag(NewFD->getLocation(), diag::err_vm_func_decl);
7873  NewFD->setInvalidDecl();
7874  }
7875 
7876  // Apply an implicit SectionAttr if #pragma code_seg is active.
7877  if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
7878  !NewFD->hasAttr<SectionAttr>()) {
7879  NewFD->addAttr(
7880  SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
7881  CodeSegStack.CurrentValue->getString(),
7882  CodeSegStack.CurrentPragmaLocation));
7883  if (UnifySection(CodeSegStack.CurrentValue->getString(),
7886  NewFD))
7887  NewFD->dropAttr<SectionAttr>();
7888  }
7889 
7890  // Handle attributes.
7891  ProcessDeclAttributes(S, NewFD, D);
7892 
7893  if (getLangOpts().OpenCL) {
7894  // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
7895  // type declaration will generate a compilation error.
7896  unsigned AddressSpace = NewFD->getReturnType().getAddressSpace();
7897  if (AddressSpace == LangAS::opencl_local ||
7898  AddressSpace == LangAS::opencl_global ||
7899  AddressSpace == LangAS::opencl_constant) {
7900  Diag(NewFD->getLocation(),
7901  diag::err_opencl_return_value_with_address_space);
7902  NewFD->setInvalidDecl();
7903  }
7904  }
7905 
7906  if (!getLangOpts().CPlusPlus) {
7907  // Perform semantic checking on the function declaration.
7908  bool isExplicitSpecialization=false;
7909  if (!NewFD->isInvalidDecl() && NewFD->isMain())
7910  CheckMain(NewFD, D.getDeclSpec());
7911 
7912  if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7913  CheckMSVCRTEntryPoint(NewFD);
7914 
7915  if (!NewFD->isInvalidDecl())
7916  D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7917  isExplicitSpecialization));
7918  else if (!Previous.empty())
7919  // Recover gracefully from an invalid redeclaration.
7920  D.setRedeclaration(true);
7921  assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7923  "previous declaration set still overloaded");
7924 
7925  // Diagnose no-prototype function declarations with calling conventions that
7926  // don't support variadic calls. Only do this in C and do it after merging
7927  // possibly prototyped redeclarations.
7928  const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
7929  if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
7930  CallingConv CC = FT->getExtInfo().getCC();
7931  if (!supportsVariadicCall(CC)) {
7932  // Windows system headers sometimes accidentally use stdcall without
7933  // (void) parameters, so we relax this to a warning.
7934  int DiagID =
7935  CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
7936  Diag(NewFD->getLocation(), DiagID)
7938  }
7939  }
7940  } else {
7941  // C++11 [replacement.functions]p3:
7942  // The program's definitions shall not be specified as inline.
7943  //
7944  // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
7945  //
7946  // Suppress the diagnostic if the function is __attribute__((used)), since
7947  // that forces an external definition to be emitted.
7948  if (D.getDeclSpec().isInlineSpecified() &&
7950  !NewFD->hasAttr<UsedAttr>())
7952  diag::ext_operator_new_delete_declared_inline)
7953  << NewFD->getDeclName();
7954 
7955  // If the declarator is a template-id, translate the parser's template
7956  // argument list into our AST format.
7958  TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
7959  TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
7960  TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
7961  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
7962  TemplateId->NumArgs);
7963  translateTemplateArguments(TemplateArgsPtr,
7964  TemplateArgs);
7965 
7966  HasExplicitTemplateArgs = true;
7967 
7968  if (NewFD->isInvalidDecl()) {
7969  HasExplicitTemplateArgs = false;
7970  } else if (FunctionTemplate) {
7971  // Function template with explicit template arguments.
7972  Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
7973  << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
7974 
7975  HasExplicitTemplateArgs = false;
7976  } else {
7977  assert((isFunctionTemplateSpecialization ||
7978  D.getDeclSpec().isFriendSpecified()) &&
7979  "should have a 'template<>' for this decl");
7980  // "friend void foo<>(int);" is an implicit specialization decl.
7981  isFunctionTemplateSpecialization = true;
7982  }
7983  } else if (isFriend && isFunctionTemplateSpecialization) {
7984  // This combination is only possible in a recovery case; the user
7985  // wrote something like:
7986  // template <> friend void foo(int);
7987  // which we're recovering from as if the user had written:
7988  // friend void foo<>(int);
7989  // Go ahead and fake up a template id.
7990  HasExplicitTemplateArgs = true;
7991  TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
7992  TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
7993  }
7994 
7995  // If it's a friend (and only if it's a friend), it's possible
7996  // that either the specialized function type or the specialized
7997  // template is dependent, and therefore matching will fail. In
7998  // this case, don't check the specialization yet.
7999  bool InstantiationDependent = false;
8000  if (isFunctionTemplateSpecialization && isFriend &&
8001  (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
8003  TemplateArgs.getArgumentArray(), TemplateArgs.size(),
8004  InstantiationDependent))) {
8005  assert(HasExplicitTemplateArgs &&
8006  "friend function specialization without template args");
8007  if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
8008  Previous))
8009  NewFD->setInvalidDecl();
8010  } else if (isFunctionTemplateSpecialization) {
8011  if (CurContext->isDependentContext() && CurContext->isRecord()
8012  && !isFriend) {
8013  isDependentClassScopeExplicitSpecialization = true;
8014  Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
8015  diag::ext_function_specialization_in_class :
8016  diag::err_function_specialization_in_class)
8017  << NewFD->getDeclName();
8018  } else if (CheckFunctionTemplateSpecialization(NewFD,
8019  (HasExplicitTemplateArgs ? &TemplateArgs
8020  : nullptr),
8021  Previous))
8022  NewFD->setInvalidDecl();
8023 
8024  // C++ [dcl.stc]p1:
8025  // A storage-class-specifier shall not be specified in an explicit
8026  // specialization (14.7.3)
8029  if (Info && SC != SC_None) {
8030  if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
8031  Diag(NewFD->getLocation(),
8032  diag::err_explicit_specialization_inconsistent_storage_class)
8033  << SC
8036 
8037  else
8038  Diag(NewFD->getLocation(),
8039  diag::ext_explicit_specialization_storage_class)
8042  }
8043 
8044  } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
8045  if (CheckMemberSpecialization(NewFD, Previous))
8046  NewFD->setInvalidDecl();
8047  }
8048 
8049  // Perform semantic checking on the function declaration.
8050  if (!isDependentClassScopeExplicitSpecialization) {
8051  if (!NewFD->isInvalidDecl() && NewFD->isMain())
8052  CheckMain(NewFD, D.getDeclSpec());
8053 
8054  if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
8055  CheckMSVCRTEntryPoint(NewFD);
8056 
8057  if (!NewFD->isInvalidDecl())
8058  D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
8059  isExplicitSpecialization));
8060  else if (!Previous.empty())
8061  // Recover gracefully from an invalid redeclaration.
8062  D.setRedeclaration(true);
8063  }
8064 
8065  assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
8067  "previous declaration set still overloaded");
8068 
8069  NamedDecl *PrincipalDecl = (FunctionTemplate
8070  ? cast<NamedDecl>(FunctionTemplate)
8071  : NewFD);
8072 
8073  if (isFriend && D.isRedeclaration()) {
8074  AccessSpecifier Access = AS_public;
8075  if (!NewFD->isInvalidDecl())
8076  Access = NewFD->getPreviousDecl()->getAccess();
8077 
8078  NewFD->setAccess(Access);
8079  if (FunctionTemplate) FunctionTemplate->setAccess(Access);
8080  }
8081 
8082  if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
8084  PrincipalDecl->setNonMemberOperator();
8085 
8086  // If we have a function template, check the template parameter
8087  // list. This will check and merge default template arguments.
8088  if (FunctionTemplate) {
8089  FunctionTemplateDecl *PrevTemplate =
8090  FunctionTemplate->getPreviousDecl();
8091  CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
8092  PrevTemplate ? PrevTemplate->getTemplateParameters()
8093  : nullptr,
8095  ? (D.isFunctionDefinition()
8096  ? TPC_FriendFunctionTemplateDefinition
8097  : TPC_FriendFunctionTemplate)
8098  : (D.getCXXScopeSpec().isSet() &&
8099  DC && DC->isRecord() &&
8100  DC->isDependentContext())
8101  ? TPC_ClassTemplateMember
8102  : TPC_FunctionTemplate);
8103  }
8104 
8105  if (NewFD->isInvalidDecl()) {
8106  // Ignore all the rest of this.
8107  } else if (!D.isRedeclaration()) {
8108  struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
8109  AddToScope };
8110  // Fake up an access specifier if it's supposed to be a class member.
8111  if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
8112  NewFD->setAccess(AS_public);
8113 
8114  // Qualified decls generally require a previous declaration.
8115  if (D.getCXXScopeSpec().isSet()) {
8116  // ...with the major exception of templated-scope or
8117  // dependent-scope friend declarations.
8118 
8119  // TODO: we currently also suppress this check in dependent
8120  // contexts because (1) the parameter depth will be off when
8121  // matching friend templates and (2) we might actually be
8122  // selecting a friend based on a dependent factor. But there
8123  // are situations where these conditions don't apply and we
8124  // can actually do this check immediately.
8125  if (isFriend &&
8126  (TemplateParamLists.size() ||
8128  CurContext->isDependentContext())) {
8129  // ignore these
8130  } else {
8131  // The user tried to provide an out-of-line definition for a
8132  // function that is a member of a class or namespace, but there
8133  // was no such member function declared (C++ [class.mfct]p2,
8134  // C++ [namespace.memdef]p2). For example:
8135  //
8136  // class X {
8137  // void f() const;
8138  // };
8139  //
8140  // void X::f() { } // ill-formed
8141  //
8142  // Complain about this problem, and attempt to suggest close
8143  // matches (e.g., those that differ only in cv-qualifiers and
8144  // whether the parameter types are references).
8145 
8147  *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
8148  AddToScope = ExtraArgs.AddToScope;
8149  return Result;
8150  }
8151  }
8152 
8153  // Unqualified local friend declarations are required to resolve
8154  // to something.
8155  } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
8157  *this, Previous, NewFD, ExtraArgs, true, S)) {
8158  AddToScope = ExtraArgs.AddToScope;
8159  return Result;
8160  }
8161  }
8162 
8163  } else if (!D.isFunctionDefinition() &&
8164  isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
8165  !isFriend && !isFunctionTemplateSpecialization &&
8166  !isExplicitSpecialization) {
8167  // An out-of-line member function declaration must also be a
8168  // definition (C++ [class.mfct]p2).
8169  // Note that this is not the case for explicit specializations of
8170  // function templates or member functions of class templates, per
8171  // C++ [temp.expl.spec]p2. We also allow these declarations as an
8172  // extension for compatibility with old SWIG code which likes to
8173  // generate them.
8174  Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
8175  << D.getCXXScopeSpec().getRange();
8176  }
8177  }
8178 
8179  ProcessPragmaWeak(S, NewFD);
8180  checkAttributesAfterMerging(*this, *NewFD);
8181 
8182  AddKnownFunctionAttributes(NewFD);
8183 
8184  if (NewFD->hasAttr<OverloadableAttr>() &&
8185  !NewFD->getType()->getAs<FunctionProtoType>()) {
8186  Diag(NewFD->getLocation(),
8187  diag::err_attribute_overloadable_no_prototype)
8188  << NewFD;
8189 
8190  // Turn this into a variadic function with no parameters.
8191  const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
8193  Context.getDefaultCallingConvention(true, false));
8194  EPI.Variadic = true;
8195  EPI.ExtInfo = FT->getExtInfo();
8196 
8197  QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
8198  NewFD->setType(R);
8199  }
8200 
8201  // If there's a #pragma GCC visibility in scope, and this isn't a class
8202  // member, set the visibility of this function.
8203  if (!DC->isRecord() && NewFD->isExternallyVisible())
8204  AddPushedVisibilityAttribute(NewFD);
8205 
8206  // If there's a #pragma clang arc_cf_code_audited in scope, consider
8207  // marking the function.
8208  AddCFAuditedAttribute(NewFD);
8209 
8210  // If this is a function definition, check if we have to apply optnone due to
8211  // a pragma.
8212  if(D.isFunctionDefinition())
8213  AddRangeBasedOptnone(NewFD);
8214 
8215  // If this is the first declaration of an extern C variable, update
8216  // the map of such variables.
8217  if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
8218  isIncompleteDeclExternC(*this, NewFD))
8219  RegisterLocallyScopedExternCDecl(NewFD, S);
8220 
8221  // Set this FunctionDecl's range up to the right paren.
8222  NewFD->setRangeEnd(D.getSourceRange().getEnd());
8223 
8224  if (D.isRedeclaration() && !Previous.empty()) {
8226  *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD,
8227  isExplicitSpecialization || isFunctionTemplateSpecialization);
8228  }
8229 
8230  if (getLangOpts().CPlusPlus) {
8231  if (FunctionTemplate) {
8232  if (NewFD->isInvalidDecl())
8233  FunctionTemplate->setInvalidDecl();
8234  return FunctionTemplate;
8235  }
8236  }
8237 
8238  if (NewFD->hasAttr<OpenCLKernelAttr>()) {
8239  // OpenCL v1.2 s6.8 static is invalid for kernel functions.
8240  if ((getLangOpts().OpenCLVersion >= 120)
8241  && (SC == SC_Static)) {
8242  Diag(D.getIdentifierLoc(), diag::err_static_kernel);
8243  D.setInvalidType();
8244  }
8245 
8246  // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
8247  if (!NewFD->getReturnType()->isVoidType()) {
8248  SourceRange RTRange = NewFD->getReturnTypeSourceRange();
8249  Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
8250  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
8251  : FixItHint());
8252  D.setInvalidType();
8253  }
8254 
8255  llvm::SmallPtrSet<const Type *, 16> ValidTypes;
8256  for (auto Param : NewFD->params())
8257  checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
8258  }
8259  for (FunctionDecl::param_iterator PI = NewFD->param_begin(),
8260  PE = NewFD->param_end(); PI != PE; ++PI) {
8261  ParmVarDecl *Param = *PI;
8262  QualType PT = Param->getType();
8263 
8264  // OpenCL 2.0 pipe restrictions forbids pipe packet types to be non-value
8265  // types.
8266  if (getLangOpts().OpenCLVersion >= 200) {
8267  if(const PipeType *PipeTy = PT->getAs<PipeType>()) {
8268  QualType ElemTy = PipeTy->getElementType();
8269  if (ElemTy->isReferenceType() || ElemTy->isPointerType()) {
8270  Diag(Param->getTypeSpecStartLoc(), diag::err_reference_pipe_type );
8271  D.setInvalidType();
8272  }
8273  }
8274  }
8275  }
8276 
8277  MarkUnusedFileScopedDecl(NewFD);
8278 
8279  if (getLangOpts().CUDA)
8280  if (IdentifierInfo *II = NewFD->getIdentifier())
8281  if (!NewFD->isInvalidDecl() &&
8283  if (II->isStr("cudaConfigureCall")) {
8284  if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
8285  Diag(NewFD->getLocation(), diag::err_config_scalar_return);
8286 
8288  }
8289  }
8290 
8291  // Here we have an function template explicit specialization at class scope.
8292  // The actually specialization will be postponed to template instatiation
8293  // time via the ClassScopeFunctionSpecializationDecl node.
8294  if (isDependentClassScopeExplicitSpecialization) {
8297  Context, CurContext, SourceLocation(),
8298  cast<CXXMethodDecl>(NewFD),
8299  HasExplicitTemplateArgs, TemplateArgs);
8300  CurContext->addDecl(NewSpec);
8301  AddToScope = false;
8302  }
8303 
8304  return NewFD;
8305 }
8306 
8307 /// \brief Perform semantic checking of a new function declaration.
8308 ///
8309 /// Performs semantic analysis of the new function declaration
8310 /// NewFD. This routine performs all semantic checking that does not
8311 /// require the actual declarator involved in the declaration, and is
8312 /// used both for the declaration of functions as they are parsed
8313 /// (called via ActOnDeclarator) and for the declaration of functions
8314 /// that have been instantiated via C++ template instantiation (called
8315 /// via InstantiateDecl).
8316 ///
8317 /// \param IsExplicitSpecialization whether this new function declaration is
8318 /// an explicit specialization of the previous declaration.
8319 ///
8320 /// This sets NewFD->isInvalidDecl() to true if there was an error.
8321 ///
8322 /// \returns true if the function declaration is a redeclaration.
8325  bool IsExplicitSpecialization) {
8326  assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
8327  "Variably modified return types are not handled here");
8328 
8329  // Determine whether the type of this function should be merged with
8330  // a previous visible declaration. This never happens for functions in C++,
8331  // and always happens in C if the previous declaration was visible.
8332  bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
8333  !Previous.isShadowed();
8334 
8335  bool Redeclaration = false;
8336  NamedDecl *OldDecl = nullptr;
8337 
8338  // Merge or overload the declaration with an existing declaration of
8339  // the same name, if appropriate.
8340  if (!Previous.empty()) {
8341  // Determine whether NewFD is an overload of PrevDecl or
8342  // a declaration that requires merging. If it's an overload,
8343  // there's no more work to do here; we'll just add the new
8344  // function to the scope.
8345  if (!AllowOverloadingOfFunction(Previous, Context)) {
8346  NamedDecl *Candidate = Previous.getRepresentativeDecl();
8347  if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
8348  Redeclaration = true;
8349  OldDecl = Candidate;
8350  }
8351  } else {
8352  switch (CheckOverload(S, NewFD, Previous, OldDecl,
8353  /*NewIsUsingDecl*/ false)) {
8354  case Ovl_Match:
8355  Redeclaration = true;
8356  break;
8357 
8358  case Ovl_NonFunction:
8359  Redeclaration = true;
8360  break;
8361 
8362  case Ovl_Overload:
8363  Redeclaration = false;
8364  break;
8365  }
8366 
8367  if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
8368  // If a function name is overloadable in C, then every function
8369  // with that name must be marked "overloadable".
8370  Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8371  << Redeclaration << NewFD;
8372  NamedDecl *OverloadedDecl = nullptr;
8373  if (Redeclaration)
8374  OverloadedDecl = OldDecl;
8375  else if (!Previous.empty())
8376  OverloadedDecl = Previous.getRepresentativeDecl();
8377  if (OverloadedDecl)
8378  Diag(OverloadedDecl->getLocation(),
8379  diag::note_attribute_overloadable_prev_overload);
8380  NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
8381  }
8382  }
8383  }
8384 
8385  // Check for a previous extern "C" declaration with this name.
8386  if (!Redeclaration &&
8387  checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
8388  if (!Previous.empty()) {
8389  // This is an extern "C" declaration with the same name as a previous
8390  // declaration, and thus redeclares that entity...
8391  Redeclaration = true;
8392  OldDecl = Previous.getFoundDecl();
8393  MergeTypeWithPrevious = false;
8394 
8395  // ... except in the presence of __attribute__((overloadable)).
8396  if (OldDecl->hasAttr<OverloadableAttr>()) {
8397  if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
8398  Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
8399  << Redeclaration << NewFD;
8400  Diag(Previous.getFoundDecl()->getLocation(),
8401  diag::note_attribute_overloadable_prev_overload);
8402  NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
8403  }
8404  if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
8405  Redeclaration = false;
8406  OldDecl = nullptr;
8407  }
8408  }
8409  }
8410  }
8411 
8412  // C++11 [dcl.constexpr]p8:
8413  // A constexpr specifier for a non-static member function that is not
8414  // a constructor declares that member function to be const.
8415  //
8416  // This needs to be delayed until we know whether this is an out-of-line
8417  // definition of a static member function.
8418  //
8419  // This rule is not present in C++1y, so we produce a backwards
8420  // compatibility warning whenever it happens in C++11.
8421  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
8422  if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
8423  !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
8424  (MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
8425  CXXMethodDecl *OldMD = nullptr;
8426  if (OldDecl)
8427  OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction());
8428  if (!OldMD || !OldMD->isStatic()) {
8429  const FunctionProtoType *FPT =
8430  MD->getType()->castAs<FunctionProtoType>();
8434  FPT->getParamTypes(), EPI));
8435 
8436  // Warn that we did this, if we're not performing template instantiation.
8437  // In that case, we'll have warned already when the template was defined.
8438  if (ActiveTemplateInstantiations.empty()) {
8439  SourceLocation AddConstLoc;
8440  if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
8442  AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
8443 
8444  Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
8445  << FixItHint::CreateInsertion(AddConstLoc, " const");
8446  }
8447  }
8448  }
8449 
8450  if (Redeclaration) {
8451  // NewFD and OldDecl represent declarations that need to be
8452  // merged.
8453  if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
8454  NewFD->setInvalidDecl();
8455  return Redeclaration;
8456  }
8457 
8458  Previous.clear();
8459  Previous.addDecl(OldDecl);
8460 
8461  if (FunctionTemplateDecl *OldTemplateDecl
8462  = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
8463  NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
8464  FunctionTemplateDecl *NewTemplateDecl
8465  = NewFD->getDescribedFunctionTemplate();
8466  assert(NewTemplateDecl && "Template/non-template mismatch");
8467  if (CXXMethodDecl *Method
8468  = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
8469  Method->setAccess(OldTemplateDecl->getAccess());
8470  NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
8471  }
8472 
8473  // If this is an explicit specialization of a member that is a function
8474  // template, mark it as a member specialization.
8475  if (IsExplicitSpecialization &&
8476  NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
8477  NewTemplateDecl->setMemberSpecialization();
8478  assert(OldTemplateDecl->isMemberSpecialization());
8479  }
8480 
8481  } else {
8482  // This needs to happen first so that 'inline' propagates.
8483  NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
8484 
8485  if (isa<CXXMethodDecl>(NewFD))
8486  NewFD->setAccess(OldDecl->getAccess());
8487  }
8488  }
8489 
8490  // Semantic checking for this function declaration (in isolation).
8491 
8492  if (getLangOpts().CPlusPlus) {
8493  // C++-specific checks.
8494  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
8495  CheckConstructor(Constructor);
8496  } else if (CXXDestructorDecl *Destructor =
8497  dyn_cast<CXXDestructorDecl>(NewFD)) {
8498  CXXRecordDecl *Record = Destructor->getParent();
8499  QualType ClassType = Context.getTypeDeclType(Record);
8500 
8501  // FIXME: Shouldn't we be able to perform this check even when the class
8502  // type is dependent? Both gcc and edg can handle that.
8503  if (!ClassType->isDependentType()) {
8504  DeclarationName Name
8506  Context.getCanonicalType(ClassType));
8507  if (NewFD->getDeclName() != Name) {
8508  Diag(NewFD->getLocation(), diag::err_destructor_name);
8509  NewFD->setInvalidDecl();
8510  return Redeclaration;
8511  }
8512  }
8513  } else if (CXXConversionDecl *Conversion
8514  = dyn_cast<CXXConversionDecl>(NewFD)) {
8515  ActOnConversionDeclarator(Conversion);
8516  }
8517 
8518  // Find any virtual functions that this function overrides.
8519  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
8520  if (!Method->isFunctionTemplateSpecialization() &&
8521  !Method->getDescribedFunctionTemplate() &&
8522  Method->isCanonicalDecl()) {
8523  if (AddOverriddenMethods(Method->getParent(), Method)) {
8524  // If the function was marked as "static", we have a problem.
8525  if (NewFD->getStorageClass() == SC_Static) {
8526  ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
8527  }
8528  }
8529  }
8530 
8531  if (Method->isStatic())
8532  checkThisInStaticMemberFunctionType(Method);
8533  }
8534 
8535  // Extra checking for C++ overloaded operators (C++ [over.oper]).
8536  if (NewFD->isOverloadedOperator() &&
8537  CheckOverloadedOperatorDeclaration(NewFD)) {
8538  NewFD->setInvalidDecl();
8539  return Redeclaration;
8540  }
8541 
8542  // Extra checking for C++0x literal operators (C++0x [over.literal]).
8543  if (NewFD->getLiteralIdentifier() &&
8544  CheckLiteralOperatorDeclaration(NewFD)) {
8545  NewFD->setInvalidDecl();
8546  return Redeclaration;
8547  }
8548 
8549  // In C++, check default arguments now that we have merged decls. Unless
8550  // the lexical context is the class, because in this case this is done
8551  // during delayed parsing anyway.
8552  if (!CurContext->isRecord())
8553  CheckCXXDefaultArguments(NewFD);
8554 
8555  // If this function declares a builtin function, check the type of this
8556  // declaration against the expected type for the builtin.
8557  if (unsigned BuiltinID = NewFD->getBuiltinID()) {
8559  LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
8560  QualType T = Context.GetBuiltinType(BuiltinID, Error);
8561  if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
8562  // The type of this function differs from the type of the builtin,
8563  // so forget about the builtin entirely.
8565  }
8566  }
8567 
8568  // If this function is declared as being extern "C", then check to see if
8569  // the function returns a UDT (class, struct, or union type) that is not C
8570  // compatible, and if it does, warn the user.
8571  // But, issue any diagnostic on the first declaration only.
8572  if (Previous.empty() && NewFD->isExternC()) {
8573  QualType R = NewFD->getReturnType();
8574  if (R->isIncompleteType() && !R->isVoidType())
8575  Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
8576  << NewFD << R;
8577  else if (!R.isPODType(Context) && !R->isVoidType() &&
8579  Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
8580  }
8581  }
8582  return Redeclaration;
8583 }
8584 
8585 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
8586  // C++11 [basic.start.main]p3:
8587  // A program that [...] declares main to be inline, static or
8588  // constexpr is ill-formed.
8589  // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
8590  // appear in a declaration of main.
8591  // static main is not an error under C99, but we should warn about it.
8592  // We accept _Noreturn main as an extension.
8593  if (FD->getStorageClass() == SC_Static)
8594  Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
8595  ? diag::err_static_main : diag::warn_static_main)
8597  if (FD->isInlineSpecified())
8598  Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
8600  if (DS.isNoreturnSpecified()) {
8601  SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
8602  SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
8603  Diag(NoreturnLoc, diag::ext_noreturn_main);
8604  Diag(NoreturnLoc, diag::note_main_remove_noreturn)
8605  << FixItHint::CreateRemoval(NoreturnRange);
8606  }
8607  if (FD->isConstexpr()) {
8608  Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
8610  FD->setConstexpr(false);
8611  }
8612 
8613  if (getLangOpts().OpenCL) {
8614  Diag(FD->getLocation(), diag::err_opencl_no_main)
8615  << FD->hasAttr<OpenCLKernelAttr>();
8616  FD->setInvalidDecl();
8617  return;
8618  }
8619 
8620  QualType T = FD->getType();
8621  assert(T->isFunctionType() && "function decl is not of function type");
8622  const FunctionType* FT = T->castAs<FunctionType>();
8623 
8624  if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
8625  // In C with GNU extensions we allow main() to have non-integer return
8626  // type, but we should warn about the extension, and we disable the
8627  // implicit-return-zero rule.
8628 
8629  // GCC in C mode accepts qualified 'int'.
8630  if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
8631  FD->setHasImplicitReturnZero(true);
8632  else {
8633  Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
8634  SourceRange RTRange = FD->getReturnTypeSourceRange();
8635  if (RTRange.isValid())
8636  Diag(RTRange.getBegin(), diag::note_main_change_return_type)
8637  << FixItHint::CreateReplacement(RTRange, "int");
8638  }
8639  } else {
8640  // In C and C++, main magically returns 0 if you fall off the end;
8641  // set the flag which tells us that.
8642  // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
8643 
8644  // All the standards say that main() should return 'int'.
8645  if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
8646  FD->setHasImplicitReturnZero(true);
8647  else {
8648  // Otherwise, this is just a flat-out error.
8649  SourceRange RTRange = FD->getReturnTypeSourceRange();
8650  Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
8651  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
8652  : FixItHint());
8653  FD->setInvalidDecl(true);
8654  }
8655  }
8656 
8657  // Treat protoless main() as nullary.
8658  if (isa<FunctionNoProtoType>(FT)) return;
8659 
8660  const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
8661  unsigned nparams = FTP->getNumParams();
8662  assert(FD->getNumParams() == nparams);
8663 
8664  bool HasExtraParameters = (nparams > 3);
8665 
8666  if (FTP->isVariadic()) {
8667  Diag(FD->getLocation(), diag::ext_variadic_main);
8668  // FIXME: if we had information about the location of the ellipsis, we
8669  // could add a FixIt hint to remove it as a parameter.
8670  }
8671 
8672  // Darwin passes an undocumented fourth argument of type char**. If
8673  // other platforms start sprouting these, the logic below will start
8674  // getting shifty.
8675  if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
8676  HasExtraParameters = false;
8677 
8678  if (HasExtraParameters) {
8679  Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
8680  FD->setInvalidDecl(true);
8681  nparams = 3;
8682  }
8683 
8684  // FIXME: a lot of the following diagnostics would be improved
8685  // if we had some location information about types.
8686 
8687  QualType CharPP =
8689  QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
8690 
8691  for (unsigned i = 0; i < nparams; ++i) {
8692  QualType AT = FTP->getParamType(i);
8693 
8694  bool mismatch = true;
8695 
8696  if (Context.hasSameUnqualifiedType(AT, Expected[i]))
8697  mismatch = false;
8698  else if (Expected[i] == CharPP) {
8699  // As an extension, the following forms are okay:
8700  // char const **
8701  // char const * const *
8702  // char * const *
8703 
8704  QualifierCollector qs;
8705  const PointerType* PT;
8706  if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
8707  (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
8709  Context.CharTy)) {
8710  qs.removeConst();
8711  mismatch = !qs.empty();
8712  }
8713  }
8714 
8715  if (mismatch) {
8716  Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
8717  // TODO: suggest replacing given type with expected type
8718  FD->setInvalidDecl(true);
8719  }
8720  }
8721 
8722  if (nparams == 1 && !FD->isInvalidDecl()) {
8723  Diag(FD->getLocation(), diag::warn_main_one_arg);
8724  }
8725 
8726  if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
8727  Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
8728  FD->setInvalidDecl();
8729  }
8730 }
8731 
8733  QualType T = FD->getType();
8734  assert(T->isFunctionType() && "function decl is not of function type");
8735  const FunctionType *FT = T->castAs<FunctionType>();
8736 
8737  // Set an implicit return of 'zero' if the function can return some integral,
8738  // enumeration, pointer or nullptr type.
8739  if (FT->getReturnType()->isIntegralOrEnumerationType() ||
8740  FT->getReturnType()->isAnyPointerType() ||
8741  FT->getReturnType()->isNullPtrType())
8742  // DllMain is exempt because a return value of zero means it failed.
8743  if (FD->getName() != "DllMain")
8744  FD->setHasImplicitReturnZero(true);
8745 
8746  if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
8747  Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
8748  FD->setInvalidDecl();
8749  }
8750 }
8751 
8753  // FIXME: Need strict checking. In C89, we need to check for
8754  // any assignment, increment, decrement, function-calls, or
8755  // commas outside of a sizeof. In C99, it's the same list,
8756  // except that the aforementioned are allowed in unevaluated
8757  // expressions. Everything else falls under the
8758  // "may accept other forms of constant expressions" exception.
8759  // (We never end up here for C++, so the constant expression
8760  // rules there don't matter.)
8761  const Expr *Culprit;
8762  if (Init->isConstantInitializer(Context, false, &Culprit))
8763  return false;
8764  Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
8765  << Culprit->getSourceRange();
8766  return true;
8767 }
8768 
8769 namespace {
8770  // Visits an initialization expression to see if OrigDecl is evaluated in
8771  // its own initialization and throws a warning if it does.
8772  class SelfReferenceChecker
8773  : public EvaluatedExprVisitor<SelfReferenceChecker> {
8774  Sema &S;
8775  Decl *OrigDecl;
8776  bool isRecordType;
8777  bool isPODType;
8778  bool isReferenceType;
8779 
8780  bool isInitList;
8781  llvm::SmallVector<unsigned, 4> InitFieldIndex;
8782  public:
8784 
8785  SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
8786  S(S), OrigDecl(OrigDecl) {
8787  isPODType = false;
8788  isRecordType = false;
8789  isReferenceType = false;
8790  isInitList = false;
8791  if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
8792  isPODType = VD->getType().isPODType(S.Context);
8793  isRecordType = VD->getType()->isRecordType();
8794  isReferenceType = VD->getType()->isReferenceType();
8795  }
8796  }
8797 
8798  // For most expressions, just call the visitor. For initializer lists,
8799  // track the index of the field being initialized since fields are
8800  // initialized in order allowing use of previously initialized fields.
8801  void CheckExpr(Expr *E) {
8802  InitListExpr *InitList = dyn_cast<InitListExpr>(E);
8803  if (!InitList) {
8804  Visit(E);
8805  return;
8806  }
8807 
8808  // Track and increment the index here.
8809  isInitList = true;
8810  InitFieldIndex.push_back(0);
8811  for (auto Child : InitList->children()) {
8812  CheckExpr(cast<Expr>(Child));
8813  ++InitFieldIndex.back();
8814  }
8815  InitFieldIndex.pop_back();
8816  }
8817 
8818  // Returns true if MemberExpr is checked and no futher checking is needed.
8819  // Returns false if additional checking is required.
8820  bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
8822  Expr *Base = E;
8823  bool ReferenceField = false;
8824 
8825  // Get the field memebers used.
8826  while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8827  FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
8828  if (!FD)
8829  return false;
8830  Fields.push_back(FD);
8831  if (FD->getType()->isReferenceType())
8832  ReferenceField = true;
8833  Base = ME->getBase()->IgnoreParenImpCasts();
8834  }
8835 
8836  // Keep checking only if the base Decl is the same.
8837  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
8838  if (!DRE || DRE->getDecl() != OrigDecl)
8839  return false;
8840 
8841  // A reference field can be bound to an unininitialized field.
8842  if (CheckReference && !ReferenceField)
8843  return true;
8844 
8845  // Convert FieldDecls to their index number.
8846  llvm::SmallVector<unsigned, 4> UsedFieldIndex;
8847  for (const FieldDecl *I : llvm::reverse(Fields))
8848  UsedFieldIndex.push_back(I->getFieldIndex());
8849 
8850  // See if a warning is needed by checking the first difference in index
8851  // numbers. If field being used has index less than the field being
8852  // initialized, then the use is safe.
8853  for (auto UsedIter = UsedFieldIndex.begin(),
8854  UsedEnd = UsedFieldIndex.end(),
8855  OrigIter = InitFieldIndex.begin(),
8856  OrigEnd = InitFieldIndex.end();
8857  UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
8858  if (*UsedIter < *OrigIter)
8859  return true;
8860  if (*UsedIter > *OrigIter)
8861  break;
8862  }
8863 
8864  // TODO: Add a different warning which will print the field names.
8865  HandleDeclRefExpr(DRE);
8866  return true;
8867  }
8868 
8869  // For most expressions, the cast is directly above the DeclRefExpr.
8870  // For conditional operators, the cast can be outside the conditional
8871  // operator if both expressions are DeclRefExpr's.
8872  void HandleValue(Expr *E) {
8873  E = E->IgnoreParens();
8874  if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
8875  HandleDeclRefExpr(DRE);
8876  return;
8877  }
8878 
8879  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
8880  Visit(CO->getCond());
8881  HandleValue(CO->getTrueExpr());
8882  HandleValue(CO->getFalseExpr());
8883  return;
8884  }
8885 
8886  if (BinaryConditionalOperator *BCO =
8887  dyn_cast<BinaryConditionalOperator>(E)) {
8888  Visit(BCO->getCond());
8889  HandleValue(BCO->getFalseExpr());
8890  return;
8891  }
8892 
8893  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
8894  HandleValue(OVE->getSourceExpr());
8895  return;
8896  }
8897 
8898  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
8899  if (BO->getOpcode() == BO_Comma) {
8900  Visit(BO->getLHS());
8901  HandleValue(BO->getRHS());
8902  return;
8903  }
8904  }
8905 
8906  if (isa<MemberExpr>(E)) {
8907  if (isInitList) {
8908  if (CheckInitListMemberExpr(cast<MemberExpr>(E),
8909  false /*CheckReference*/))
8910  return;
8911  }
8912 
8913  Expr *Base = E->IgnoreParenImpCasts();
8914  while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8915  // Check for static member variables and don't warn on them.
8916  if (!isa<FieldDecl>(ME->getMemberDecl()))
8917  return;
8918  Base = ME->getBase()->IgnoreParenImpCasts();
8919  }
8920  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
8921  HandleDeclRefExpr(DRE);
8922  return;
8923  }
8924 
8925  Visit(E);
8926  }
8927 
8928  // Reference types not handled in HandleValue are handled here since all
8929  // uses of references are bad, not just r-value uses.
8930  void VisitDeclRefExpr(DeclRefExpr *E) {
8931  if (isReferenceType)
8932  HandleDeclRefExpr(E);
8933  }
8934 
8935  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
8936  if (E->getCastKind() == CK_LValueToRValue) {
8937  HandleValue(E->getSubExpr());
8938  return;
8939  }
8940 
8941  Inherited::VisitImplicitCastExpr(E);
8942  }
8943 
8944  void VisitMemberExpr(MemberExpr *E) {
8945  if (isInitList) {
8946  if (CheckInitListMemberExpr(E, true /*CheckReference*/))
8947  return;
8948  }
8949 
8950  // Don't warn on arrays since they can be treated as pointers.
8951  if (E->getType()->canDecayToPointerType()) return;
8952 
8953  // Warn when a non-static method call is followed by non-static member
8954  // field accesses, which is followed by a DeclRefExpr.
8955  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
8956  bool Warn = (MD && !MD->isStatic());
8957  Expr *Base = E->getBase()->IgnoreParenImpCasts();
8958  while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8959  if (!isa<FieldDecl>(ME->getMemberDecl()))
8960  Warn = false;
8961  Base = ME->getBase()->IgnoreParenImpCasts();
8962  }
8963 
8964  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
8965  if (Warn)
8966  HandleDeclRefExpr(DRE);
8967  return;
8968  }
8969 
8970  // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
8971  // Visit that expression.
8972  Visit(Base);
8973  }
8974 
8975  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
8976  Expr *Callee = E->getCallee();
8977 
8978  if (isa<UnresolvedLookupExpr>(Callee))
8979  return Inherited::VisitCXXOperatorCallExpr(E);
8980 
8981  Visit(Callee);
8982  for (auto Arg: E->arguments())
8983  HandleValue(Arg->IgnoreParenImpCasts());
8984  }
8985 
8986  void VisitUnaryOperator(UnaryOperator *E) {
8987  // For POD record types, addresses of its own members are well-defined.
8988  if (E->getOpcode() == UO_AddrOf && isRecordType &&
8989  isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
8990  if (!isPODType)
8991  HandleValue(E->getSubExpr());
8992  return;
8993  }
8994 
8995  if (E->isIncrementDecrementOp()) {
8996  HandleValue(E->getSubExpr());
8997  return;
8998  }
8999 
9000  Inherited::VisitUnaryOperator(E);
9001  }
9002 
9003  void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; }
9004 
9005  void VisitCXXConstructExpr(CXXConstructExpr *E) {
9006  if (E->getConstructor()->isCopyConstructor()) {
9007  Expr *ArgExpr = E->getArg(0);
9008  if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
9009  if (ILE->getNumInits() == 1)
9010  ArgExpr = ILE->getInit(0);
9011  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
9012  if (ICE->getCastKind() == CK_NoOp)
9013  ArgExpr = ICE->getSubExpr();
9014  HandleValue(ArgExpr);
9015  return;
9016  }
9017  Inherited::VisitCXXConstructExpr(E);
9018  }
9019 
9020  void VisitCallExpr(CallExpr *E) {
9021  // Treat std::move as a use.
9022  if (E->getNumArgs() == 1) {
9023  if (FunctionDecl *FD = E->getDirectCallee()) {
9024  if (FD->isInStdNamespace() && FD->getIdentifier() &&
9025  FD->getIdentifier()->isStr("move")) {
9026  HandleValue(E->getArg(0));
9027  return;
9028  }
9029  }
9030  }
9031 
9032  Inherited::VisitCallExpr(E);
9033  }
9034 
9035  void VisitBinaryOperator(BinaryOperator *E) {
9036  if (E->isCompoundAssignmentOp()) {
9037  HandleValue(E->getLHS());
9038  Visit(E->getRHS());
9039  return;
9040  }
9041 
9042  Inherited::VisitBinaryOperator(E);
9043  }
9044 
9045  // A custom visitor for BinaryConditionalOperator is needed because the
9046  // regular visitor would check the condition and true expression separately
9047  // but both point to the same place giving duplicate diagnostics.
9048  void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
9049  Visit(E->getCond());
9050  Visit(E->getFalseExpr());
9051  }
9052 
9053  void HandleDeclRefExpr(DeclRefExpr *DRE) {
9054  Decl* ReferenceDecl = DRE->getDecl();
9055  if (OrigDecl != ReferenceDecl) return;
9056  unsigned diag;
9057  if (isReferenceType) {
9058  diag = diag::warn_uninit_self_reference_in_reference_init;
9059  } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
9060  diag = diag::warn_static_self_reference_in_init;
9061  } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) ||
9062  isa<NamespaceDecl>(OrigDecl->getDeclContext()) ||
9063  DRE->getDecl()->getType()->isRecordType()) {
9064  diag = diag::warn_uninit_self_reference_in_init;
9065  } else {
9066  // Local variables will be handled by the CFG analysis.
9067  return;
9068  }
9069 
9070  S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
9071  S.PDiag(diag)
9072  << DRE->getNameInfo().getName()
9073  << OrigDecl->getLocation()
9074  << DRE->getSourceRange());
9075  }
9076  };
9077 
9078  /// CheckSelfReference - Warns if OrigDecl is used in expression E.
9079  static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
9080  bool DirectInit) {
9081  // Parameters arguments are occassionially constructed with itself,
9082  // for instance, in recursive functions. Skip them.
9083  if (isa<ParmVarDecl>(OrigDecl))
9084  return;
9085 
9086  E = E->IgnoreParens();
9087 
9088  // Skip checking T a = a where T is not a record or reference type.
9089  // Doing so is a way to silence uninitialized warnings.
9090  if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
9091  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
9092  if (ICE->getCastKind() == CK_LValueToRValue)
9093  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
9094  if (DRE->getDecl() == OrigDecl)
9095  return;
9096 
9097  SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
9098  }
9099 }
9100 
9103  TypeSourceInfo *TSI,
9104  SourceRange Range, bool DirectInit,
9105  Expr *Init) {
9106  bool IsInitCapture = !VDecl;
9107  assert((!VDecl || !VDecl->isInitCapture()) &&
9108  "init captures are expected to be deduced prior to initialization");
9109 
9110  ArrayRef<Expr *> DeduceInits = Init;
9111  if (DirectInit) {
9112  if (auto *PL = dyn_cast<ParenListExpr>(Init))
9113  DeduceInits = PL->exprs();
9114  else if (auto *IL = dyn_cast<InitListExpr>(Init))
9115  DeduceInits = IL->inits();
9116  }
9117 
9118  // Deduction only works if we have exactly one source expression.
9119  if (DeduceInits.empty()) {
9120  // It isn't possible to write this directly, but it is possible to
9121  // end up in this situation with "auto x(some_pack...);"
9122  Diag(Init->getLocStart(), IsInitCapture
9123  ? diag::err_init_capture_no_expression
9124  : diag::err_auto_var_init_no_expression)
9125  << Name << Type << Range;
9126  return QualType();
9127  }
9128 
9129  if (DeduceInits.size() > 1) {
9130  Diag(DeduceInits[1]->getLocStart(),
9131  IsInitCapture ? diag::err_init_capture_multiple_expressions
9132  : diag::err_auto_var_init_multiple_expressions)
9133  << Name << Type << Range;
9134  return QualType();
9135  }
9136 
9137  Expr *DeduceInit = DeduceInits[0];
9138  if (DirectInit && isa<InitListExpr>(DeduceInit)) {
9139  Diag(Init->getLocStart(), IsInitCapture
9140  ? diag::err_init_capture_paren_braces
9141  : diag::err_auto_var_init_paren_braces)
9142  << isa<InitListExpr>(Init) << Name << Type << Range;
9143  return QualType();
9144  }
9145 
9146  // Expressions default to 'id' when we're in a debugger.
9147  bool DefaultedAnyToId = false;
9148  if (getLangOpts().DebuggerCastResultToId &&
9149  Init->getType() == Context.UnknownAnyTy && !IsInitCapture) {
9150  ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
9151  if (Result.isInvalid()) {
9152  return QualType();
9153  }
9154  Init = Result.get();
9155  DefaultedAnyToId = true;
9156  }
9157 
9158  QualType DeducedType;
9159  if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
9160  if (!IsInitCapture)
9161  DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
9162  else if (isa<InitListExpr>(Init))
9163  Diag(Range.getBegin(),
9164  diag::err_init_capture_deduction_failure_from_init_list)
9165  << Name
9166  << (DeduceInit->getType().isNull() ? TSI->getType()
9167  : DeduceInit->getType())
9168  << DeduceInit->getSourceRange();
9169  else
9170  Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
9171  << Name << TSI->getType()
9172  << (DeduceInit->getType().isNull() ? TSI->getType()
9173  : DeduceInit->getType())
9174  << DeduceInit->getSourceRange();
9175  }
9176 
9177  // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
9178  // 'id' instead of a specific object type prevents most of our usual
9179  // checks.
9180  // We only want to warn outside of template instantiations, though:
9181  // inside a template, the 'id' could have come from a parameter.
9182  if (ActiveTemplateInstantiations.empty() && !DefaultedAnyToId &&
9183  !IsInitCapture && !DeducedType.isNull() && DeducedType->isObjCIdType()) {
9184  SourceLocation Loc = TSI->getTypeLoc().getBeginLoc();
9185  Diag(Loc, diag::warn_auto_var_is_id) << Name << Range;
9186  }
9187 
9188  return DeducedType;
9189 }
9190 
9191 /// AddInitializerToDecl - Adds the initializer Init to the
9192 /// declaration dcl. If DirectInit is true, this is C++ direct
9193 /// initialization rather than copy initialization.
9194 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
9195  bool DirectInit, bool TypeMayContainAuto) {
9196  // If there is no declaration, there was an error parsing it. Just ignore
9197  // the initializer.
9198  if (!RealDecl || RealDecl->isInvalidDecl()) {
9199  CorrectDelayedTyposInExpr(Init, dyn_cast_or_null<VarDecl>(RealDecl));
9200  return;
9201  }
9202 
9203  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
9204  // Pure-specifiers are handled in ActOnPureSpecifier.
9205  Diag(Method->getLocation(), diag::err_member_function_initialization)
9206  << Method->getDeclName() << Init->getSourceRange();
9207  Method->setInvalidDecl();
9208  return;
9209  }
9210 
9211  VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
9212  if (!VDecl) {
9213  assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
9214  Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
9215  RealDecl->setInvalidDecl();
9216  return;
9217  }
9218 
9219  // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
9220  if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
9221  // Attempt typo correction early so that the type of the init expression can
9222  // be deduced based on the chosen correction if the original init contains a
9223  // TypoExpr.
9224  ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
9225  if (!Res.isUsable()) {
9226  RealDecl->setInvalidDecl();
9227  return;
9228  }
9229  Init = Res.get();
9230 
9231  QualType DeducedType = deduceVarTypeFromInitializer(
9232  VDecl, VDecl->getDeclName(), VDecl->getType(),
9233  VDecl->getTypeSourceInfo(), VDecl->getSourceRange(), DirectInit, Init);
9234  if (DeducedType.isNull()) {
9235  RealDecl->setInvalidDecl();
9236  return;
9237  }
9238 
9239  VDecl->setType(DeducedType);
9240  assert(VDecl->isLinkageValid());
9241 
9242  // In ARC, infer lifetime.
9243  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
9244  VDecl->setInvalidDecl();
9245 
9246  // If this is a redeclaration, check that the type we just deduced matches
9247  // the previously declared type.
9248  if (VarDecl *Old = VDecl->getPreviousDecl()) {
9249  // We never need to merge the type, because we cannot form an incomplete
9250  // array of auto, nor deduce such a type.
9251  MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/ false);
9252  }
9253 
9254  // Check the deduced type is valid for a variable declaration.
9255  CheckVariableDeclarationType(VDecl);
9256  if (VDecl->isInvalidDecl())
9257  return;
9258  }
9259 
9260  // dllimport cannot be used on variable definitions.
9261  if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
9262  Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
9263  VDecl->setInvalidDecl();
9264  return;
9265  }
9266 
9267  if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
9268  // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
9269  Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
9270  VDecl->setInvalidDecl();
9271  return;
9272  }
9273 
9274  if (!VDecl->getType()->isDependentType()) {
9275  // A definition must end up with a complete type, which means it must be
9276  // complete with the restriction that an array type might be completed by
9277  // the initializer; note that later code assumes this restriction.
9278  QualType BaseDeclType = VDecl->getType();
9279  if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
9280  BaseDeclType = Array->getElementType();
9281  if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
9282  diag::err_typecheck_decl_incomplete_type)) {
9283  RealDecl->setInvalidDecl();
9284  return;
9285  }
9286 
9287  // The variable can not have an abstract class type.
9288  if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
9289  diag::err_abstract_type_in_decl,
9290  AbstractVariableType))
9291  VDecl->setInvalidDecl();
9292  }
9293 
9294  VarDecl *Def;
9295  if ((Def = VDecl->getDefinition()) && Def != VDecl) {
9296  NamedDecl *Hidden = nullptr;
9297  if (!hasVisibleDefinition(Def, &Hidden) &&
9298  (VDecl->getFormalLinkage() == InternalLinkage ||
9299  VDecl->getDescribedVarTemplate() ||
9300  VDecl->getNumTemplateParameterLists() ||
9301  VDecl->getDeclContext()->isDependentContext())) {
9302  // The previous definition is hidden, and multiple definitions are
9303  // permitted (in separate TUs). Form another definition of it.
9304  } else {
9305  Diag(VDecl->getLocation(), diag::err_redefinition)
9306  << VDecl->getDeclName();
9307  Diag(Def->getLocation(), diag::note_previous_definition);
9308  VDecl->setInvalidDecl();
9309  return;
9310  }
9311  }
9312 
9313  if (getLangOpts().CPlusPlus) {
9314  // C++ [class.static.data]p4
9315  // If a static data member is of const integral or const
9316  // enumeration type, its declaration in the class definition can
9317  // specify a constant-initializer which shall be an integral
9318  // constant expression (5.19). In that case, the member can appear
9319  // in integral constant expressions. The member shall still be
9320  // defined in a namespace scope if it is used in the program and the
9321  // namespace scope definition shall not contain an initializer.
9322  //
9323  // We already performed a redefinition check above, but for static
9324  // data members we also need to check whether there was an in-class
9325  // declaration with an initializer.
9326  if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {
9327  Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
9328  << VDecl->getDeclName();
9329  Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(),
9330  diag::note_previous_initializer)
9331  << 0;
9332  return;
9333  }
9334 
9335  if (VDecl->hasLocalStorage())
9336  getCurFunction()->setHasBranchProtectedScope();
9337 
9338  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
9339  VDecl->setInvalidDecl();
9340  return;
9341  }
9342  }
9343 
9344  // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
9345  // a kernel function cannot be initialized."
9346  if (VDecl->getType().getAddressSpace() == LangAS::opencl_local) {
9347  Diag(VDecl->getLocation(), diag::err_local_cant_init);
9348  VDecl->setInvalidDecl();
9349  return;
9350  }
9351 
9352  // Get the decls type and save a reference for later, since
9353  // CheckInitializerTypes may change it.
9354  QualType DclT = VDecl->getType(), SavT = DclT;
9355 
9356  // Expressions default to 'id' when we're in a debugger
9357  // and we are assigning it to a variable of Objective-C pointer type.
9358  if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
9359  Init->getType() == Context.UnknownAnyTy) {
9360  ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
9361  if (Result.isInvalid()) {
9362  VDecl->setInvalidDecl();
9363  return;
9364  }
9365  Init = Result.get();
9366  }
9367 
9368  // Perform the initialization.
9369  ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
9370  if (!VDecl->isInvalidDecl()) {
9373  DirectInit
9374  ? CXXDirectInit
9376  Init->getLocStart(),
9377  Init->getLocEnd())
9380  Init->getLocStart());
9381 
9382  MultiExprArg Args = Init;
9383  if (CXXDirectInit)
9384  Args = MultiExprArg(CXXDirectInit->getExprs(),
9385  CXXDirectInit->getNumExprs());
9386 
9387  // Try to correct any TypoExprs in the initialization arguments.
9388  for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
9389  ExprResult Res = CorrectDelayedTyposInExpr(
9390  Args[Idx], VDecl, [this, Entity, Kind](Expr *E) {
9391  InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E));
9392  return Init.Failed() ? ExprError() : E;
9393  });
9394  if (Res.isInvalid()) {
9395  VDecl->setInvalidDecl();
9396  } else if (Res.get() != Args[Idx]) {
9397  Args[Idx] = Res.get();
9398  }
9399  }
9400  if (VDecl->isInvalidDecl())
9401  return;
9402 
9403  InitializationSequence InitSeq(*this, Entity, Kind, Args);
9404  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
9405  if (Result.isInvalid()) {
9406  VDecl->setInvalidDecl();
9407  return;
9408  }
9409 
9410  Init = Result.getAs<Expr>();
9411  }
9412 
9413  // Check for self-references within variable initializers.
9414  // Variables declared within a function/method body (except for references)
9415  // are handled by a dataflow analysis.
9416  if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
9417  VDecl->getType()->isReferenceType()) {
9418  CheckSelfReference(*this, RealDecl, Init, DirectInit);
9419  }
9420 
9421  // If the type changed, it means we had an incomplete type that was
9422  // completed by the initializer. For example:
9423  // int ary[] = { 1, 3, 5 };
9424  // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
9425  if (!VDecl->isInvalidDecl() && (DclT != SavT))
9426  VDecl->setType(DclT);
9427 
9428  if (!VDecl->isInvalidDecl()) {
9429  checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
9430 
9431  if (VDecl->hasAttr<BlocksAttr>())
9432  checkRetainCycles(VDecl, Init);
9433 
9434  // It is safe to assign a weak reference into a strong variable.
9435  // Although this code can still have problems:
9436  // id x = self.weakProp;
9437  // id y = self.weakProp;
9438  // we do not warn to warn spuriously when 'x' and 'y' are on separate
9439  // paths through the function. This should be revisited if
9440  // -Wrepeated-use-of-weak is made flow-sensitive.
9441  if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong &&
9442  !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
9443  Init->getLocStart()))
9444  getCurFunction()->markSafeWeakUse(Init);
9445  }
9446 
9447  // The initialization is usually a full-expression.
9448  //
9449  // FIXME: If this is a braced initialization of an aggregate, it is not
9450  // an expression, and each individual field initializer is a separate
9451  // full-expression. For instance, in:
9452  //
9453  // struct Temp { ~Temp(); };
9454  // struct S { S(Temp); };
9455  // struct T { S a, b; } t = { Temp(), Temp() }
9456  //
9457  // we should destroy the first Temp before constructing the second.
9458  ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
9459  false,
9460  VDecl->isConstexpr());
9461  if (Result.isInvalid()) {
9462  VDecl->setInvalidDecl();
9463  return;
9464  }
9465  Init = Result.get();
9466 
9467  // Attach the initializer to the decl.
9468  VDecl->setInit(Init);
9469 
9470  if (VDecl->isLocalVarDecl()) {
9471  // C99 6.7.8p4: All the expressions in an initializer for an object that has
9472  // static storage duration shall be constant expressions or string literals.
9473  // C++ does not have this restriction.
9474  if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) {
9475  const Expr *Culprit;
9476  if (VDecl->getStorageClass() == SC_Static)
9477  CheckForConstantInitializer(Init, DclT);
9478  // C89 is stricter than C99 for non-static aggregate types.
9479  // C89 6.5.7p3: All the expressions [...] in an initializer list
9480  // for an object that has aggregate or union type shall be
9481  // constant expressions.
9482  else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
9483  isa<InitListExpr>(Init) &&
9484  !Init->isConstantInitializer(Context, false, &Culprit))
9485  Diag(Culprit->getExprLoc(),
9486  diag::ext_aggregate_init_not_constant)
9487  << Culprit->getSourceRange();
9488  }
9489  } else if (VDecl->isStaticDataMember() &&
9490  VDecl->getLexicalDeclContext()->isRecord()) {
9491  // This is an in-class initialization for a static data member, e.g.,
9492  //
9493  // struct S {
9494  // static const int value = 17;
9495  // };
9496 
9497  // C++ [class.mem]p4:
9498  // A member-declarator can contain a constant-initializer only
9499  // if it declares a static member (9.4) of const integral or
9500  // const enumeration type, see 9.4.2.
9501  //
9502  // C++11 [class.static.data]p3:
9503  // If a non-volatile const static data member is of integral or
9504  // enumeration type, its declaration in the class definition can
9505  // specify a brace-or-equal-initializer in which every initalizer-clause
9506  // that is an assignment-expression is a constant expression. A static
9507  // data member of literal type can be declared in the class definition
9508  // with the constexpr specifier; if so, its declaration shall specify a
9509  // brace-or-equal-initializer in which every initializer-clause that is
9510  // an assignment-expression is a constant expression.
9511 
9512  // Do nothing on dependent types.
9513  if (DclT->isDependentType()) {
9514 
9515  // Allow any 'static constexpr' members, whether or not they are of literal
9516  // type. We separately check that every constexpr variable is of literal
9517  // type.
9518  } else if (VDecl->isConstexpr()) {
9519 
9520  // Require constness.
9521  } else if (!DclT.isConstQualified()) {
9522  Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
9523  << Init->getSourceRange();
9524  VDecl->setInvalidDecl();
9525 
9526  // We allow integer constant expressions in all cases.
9527  } else if (DclT->isIntegralOrEnumerationType()) {
9528  // Check whether the expression is a constant expression.
9529  SourceLocation Loc;
9530  if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
9531  // In C++11, a non-constexpr const static data member with an
9532  // in-class initializer cannot be volatile.
9533  Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
9534  else if (Init->isValueDependent())
9535  ; // Nothing to check.
9536  else if (Init->isIntegerConstantExpr(Context, &Loc))
9537  ; // Ok, it's an ICE!
9538  else if (Init->isEvaluatable(Context)) {
9539  // If we can constant fold the initializer through heroics, accept it,
9540  // but report this as a use of an extension for -pedantic.
9541  Diag(Loc, diag::ext_in_class_initializer_non_constant)
9542  << Init->getSourceRange();
9543  } else {
9544  // Otherwise, this is some crazy unknown case. Report the issue at the
9545  // location provided by the isIntegerConstantExpr failed check.
9546  Diag(Loc, diag::err_in_class_initializer_non_constant)
9547  << Init->getSourceRange();
9548  VDecl->setInvalidDecl();
9549  }
9550 
9551  // We allow foldable floating-point constants as an extension.
9552  } else if (DclT->isFloatingType()) { // also permits complex, which is ok
9553  // In C++98, this is a GNU extension. In C++11, it is not, but we support
9554  // it anyway and provide a fixit to add the 'constexpr'.
9555  if (getLangOpts().CPlusPlus11) {
9556  Diag(VDecl->getLocation(),
9557  diag::ext_in_class_initializer_float_type_cxx11)
9558  << DclT << Init->getSourceRange();
9559  Diag(VDecl->getLocStart(),
9560  diag::note_in_class_initializer_float_type_cxx11)
9561  << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
9562  } else {
9563  Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
9564  << DclT << Init->getSourceRange();
9565 
9566  if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
9567  Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
9568  << Init->getSourceRange();
9569  VDecl->setInvalidDecl();
9570  }
9571  }
9572 
9573  // Suggest adding 'constexpr' in C++11 for literal types.
9574  } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
9575  Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
9576  << DclT << Init->getSourceRange()
9577  << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
9578  VDecl->setConstexpr(true);
9579 
9580  } else {
9581  Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
9582  << DclT << Init->getSourceRange();
9583  VDecl->setInvalidDecl();
9584  }
9585  } else if (VDecl->isFileVarDecl()) {
9586  if (VDecl->getStorageClass() == SC_Extern &&
9587  (!getLangOpts().CPlusPlus ||
9588  !(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
9589  VDecl->isExternC())) &&
9591  Diag(VDecl->getLocation(), diag::warn_extern_init);
9592 
9593  // C99 6.7.8p4. All file scoped initializers need to be constant.
9594  if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
9595  CheckForConstantInitializer(Init, DclT);
9596  }
9597 
9598  // We will represent direct-initialization similarly to copy-initialization:
9599  // int x(1); -as-> int x = 1;
9600  // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
9601  //
9602  // Clients that want to distinguish between the two forms, can check for
9603  // direct initializer using VarDecl::getInitStyle().
9604  // A major benefit is that clients that don't particularly care about which
9605  // exactly form was it (like the CodeGen) can handle both cases without
9606  // special case code.
9607 
9608  // C++ 8.5p11:
9609  // The form of initialization (using parentheses or '=') is generally
9610  // insignificant, but does matter when the entity being initialized has a
9611  // class type.
9612  if (CXXDirectInit) {
9613  assert(DirectInit && "Call-style initializer must be direct init.");
9615  } else if (DirectInit) {
9616  // This must be list-initialization. No other way is direct-initialization.
9618  }
9619 
9620  CheckCompleteVariableDeclaration(VDecl);
9621 }
9622 
9623 /// ActOnInitializerError - Given that there was an error parsing an
9624 /// initializer for the given declaration, try to return to some form
9625 /// of sanity.
9627  // Our main concern here is re-establishing invariants like "a
9628  // variable's type is either dependent or complete".
9629  if (!D || D->isInvalidDecl()) return;
9630 
9631  VarDecl *VD = dyn_cast<VarDecl>(D);
9632  if (!VD) return;
9633 
9634  // Auto types are meaningless if we can't make sense of the initializer.
9635  if (ParsingInitForAutoVars.count(D)) {
9636  D->setInvalidDecl();
9637  return;
9638  }
9639 
9640  QualType Ty = VD->getType();
9641  if (Ty->isDependentType()) return;
9642 
9643  // Require a complete type.
9644  if (RequireCompleteType(VD->getLocation(),
9646  diag::err_typecheck_decl_incomplete_type)) {
9647  VD->setInvalidDecl();
9648  return;
9649  }
9650 
9651  // Require a non-abstract type.
9652  if (RequireNonAbstractType(VD->getLocation(), Ty,
9653  diag::err_abstract_type_in_decl,
9654  AbstractVariableType)) {
9655  VD->setInvalidDecl();
9656  return;
9657  }
9658 
9659  // Don't bother complaining about constructors or destructors,
9660  // though.
9661 }
9662 
9664  bool TypeMayContainAuto) {
9665  // If there is no declaration, there was an error parsing it. Just ignore it.
9666  if (!RealDecl)
9667  return;
9668 
9669  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
9670  QualType Type = Var->getType();
9671 
9672  // C++11 [dcl.spec.auto]p3
9673  if (TypeMayContainAuto && Type->getContainedAutoType()) {
9674  Diag(Var->getLocation(), diag::err_auto_var_requires_init)
9675  << Var->getDeclName() << Type;
9676  Var->setInvalidDecl();
9677  return;
9678  }
9679 
9680  // C++11 [class.static.data]p3: A static data member can be declared with
9681  // the constexpr specifier; if so, its declaration shall specify
9682  // a brace-or-equal-initializer.
9683  // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
9684  // the definition of a variable [...] or the declaration of a static data
9685  // member.
9686  if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
9687  if (Var->isStaticDataMember())
9688  Diag(Var->getLocation(),
9689  diag::err_constexpr_static_mem_var_requires_init)
9690  << Var->getDeclName();
9691  else
9692  Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
9693  Var->setInvalidDecl();
9694  return;
9695  }
9696 
9697  // C++ Concepts TS [dcl.spec.concept]p1: [...] A variable template
9698  // definition having the concept specifier is called a variable concept. A
9699  // concept definition refers to [...] a variable concept and its initializer.
9700  if (Var->isConcept()) {
9701  Diag(Var->getLocation(), diag::err_var_concept_not_initialized);
9702  Var->setInvalidDecl();
9703  return;
9704  }
9705 
9706  // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
9707  // be initialized.
9708  if (!Var->isInvalidDecl() &&
9709  Var->getType().getAddressSpace() == LangAS::opencl_constant &&
9710  Var->getStorageClass() != SC_Extern && !Var->getInit()) {
9711  Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
9712  Var->setInvalidDecl();
9713  return;
9714  }
9715 
9716  switch (Var->isThisDeclarationADefinition()) {
9717  case VarDecl::Definition:
9718  if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
9719  break;
9720 
9721  // We have an out-of-line definition of a static data member
9722  // that has an in-class initializer, so we type-check this like
9723  // a declaration.
9724  //
9725  // Fall through
9726 
9728  // It's only a declaration.
9729 
9730  // Block scope. C99 6.7p7: If an identifier for an object is
9731  // declared with no linkage (C99 6.2.2p6), the type for the
9732  // object shall be complete.
9733  if (!Type->isDependentType() && Var->isLocalVarDecl() &&
9734  !Var->hasLinkage() && !Var->isInvalidDecl() &&
9735  RequireCompleteType(Var->getLocation(), Type,
9736  diag::err_typecheck_decl_incomplete_type))
9737  Var->setInvalidDecl();
9738 
9739  // Make sure that the type is not abstract.
9740  if (!Type->isDependentType() && !Var->isInvalidDecl() &&
9741  RequireNonAbstractType(Var->getLocation(), Type,
9742  diag::err_abstract_type_in_decl,
9743  AbstractVariableType))
9744  Var->setInvalidDecl();
9745  if (!Type->isDependentType() && !Var->isInvalidDecl() &&
9746  Var->getStorageClass() == SC_PrivateExtern) {
9747  Diag(Var->getLocation(), diag::warn_private_extern);
9748  Diag(Var->getLocation(), diag::note_private_extern);
9749  }
9750 
9751  return;
9752 
9754  // File scope. C99 6.9.2p2: A declaration of an identifier for an
9755  // object that has file scope without an initializer, and without a
9756  // storage-class specifier or with the storage-class specifier "static",
9757  // constitutes a tentative definition. Note: A tentative definition with
9758  // external linkage is valid (C99 6.2.2p5).
9759  if (!Var->isInvalidDecl()) {
9760  if (const IncompleteArrayType *ArrayT
9762  if (RequireCompleteType(Var->getLocation(),
9763  ArrayT->getElementType(),
9764  diag::err_illegal_decl_array_incomplete_type))
9765  Var->setInvalidDecl();
9766  } else if (Var->getStorageClass() == SC_Static) {
9767  // C99 6.9.2p3: If the declaration of an identifier for an object is
9768  // a tentative definition and has internal linkage (C99 6.2.2p3), the
9769  // declared type shall not be an incomplete type.
9770  // NOTE: code such as the following
9771  // static struct s;
9772  // struct s { int a; };
9773  // is accepted by gcc. Hence here we issue a warning instead of
9774  // an error and we do not invalidate the static declaration.
9775  // NOTE: to avoid multiple warnings, only check the first declaration.
9776  if (Var->isFirstDecl())
9777  RequireCompleteType(Var->getLocation(), Type,
9778  diag::ext_typecheck_decl_incomplete_type);
9779  }
9780  }
9781 
9782  // Record the tentative definition; we're done.
9783  if (!Var->isInvalidDecl())
9784  TentativeDefinitions.push_back(Var);
9785  return;
9786  }
9787 
9788  // Provide a specific diagnostic for uninitialized variable
9789  // definitions with incomplete array type.
9790  if (Type->isIncompleteArrayType()) {
9791  Diag(Var->getLocation(),
9792  diag::err_typecheck_incomplete_array_needs_initializer);
9793  Var->setInvalidDecl();
9794  return;
9795  }
9796 
9797  // Provide a specific diagnostic for uninitialized variable
9798  // definitions with reference type.
9799  if (Type->isReferenceType()) {
9800  Diag(Var->getLocation(), diag::err_reference_var_requires_init)
9801  << Var->getDeclName()
9802  << SourceRange(Var->getLocation(), Var->getLocation());
9803  Var->setInvalidDecl();
9804  return;
9805  }
9806 
9807  // Do not attempt to type-check the default initializer for a
9808  // variable with dependent type.
9809  if (Type->isDependentType())
9810  return;
9811 
9812  if (Var->isInvalidDecl())
9813  return;
9814 
9815  if (!Var->hasAttr<AliasAttr>()) {
9816  if (RequireCompleteType(Var->getLocation(),
9818  diag::err_typecheck_decl_incomplete_type)) {
9819  Var->setInvalidDecl();
9820  return;
9821  }
9822  } else {
9823  return;
9824  }
9825 
9826  // The variable can not have an abstract class type.
9827  if (RequireNonAbstractType(Var->getLocation(), Type,
9828  diag::err_abstract_type_in_decl,
9829  AbstractVariableType)) {
9830  Var->setInvalidDecl();
9831  return;
9832  }
9833 
9834  // Check for jumps past the implicit initializer. C++0x
9835  // clarifies that this applies to a "variable with automatic
9836  // storage duration", not a "local variable".
9837  // C++11 [stmt.dcl]p3
9838  // A program that jumps from a point where a variable with automatic
9839  // storage duration is not in scope to a point where it is in scope is
9840  // ill-formed unless the variable has scalar type, class type with a
9841  // trivial default constructor and a trivial destructor, a cv-qualified
9842  // version of one of these types, or an array of one of the preceding
9843  // types and is declared without an initializer.
9844  if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
9845  if (const RecordType *Record
9847  CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
9848  // Mark the function for further checking even if the looser rules of
9849  // C++11 do not require such checks, so that we can diagnose
9850  // incompatibilities with C++98.
9851  if (!CXXRecord->isPOD())
9852  getCurFunction()->setHasBranchProtectedScope();
9853  }
9854  }
9855 
9856  // C++03 [dcl.init]p9:
9857  // If no initializer is specified for an object, and the
9858  // object is of (possibly cv-qualified) non-POD class type (or
9859  // array thereof), the object shall be default-initialized; if
9860  // the object is of const-qualified type, the underlying class
9861  // type shall have a user-declared default
9862  // constructor. Otherwise, if no initializer is specified for
9863  // a non- static object, the object and its subobjects, if
9864  // any, have an indeterminate initial value); if the object
9865  // or any of its subobjects are of const-qualified type, the
9866  // program is ill-formed.
9867  // C++0x [dcl.init]p11:
9868  // If no initializer is specified for an object, the object is
9869  // default-initialized; [...].
9872  = InitializationKind::CreateDefault(Var->getLocation());
9873 
9874  InitializationSequence InitSeq(*this, Entity, Kind, None);
9875  ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
9876  if (Init.isInvalid())
9877  Var->setInvalidDecl();
9878  else if (Init.get()) {
9879  Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
9880  // This is important for template substitution.
9881  Var->setInitStyle(VarDecl::CallInit);
9882  }
9883 
9884  CheckCompleteVariableDeclaration(Var);
9885  }
9886 }
9887 
9889  VarDecl *VD = dyn_cast<VarDecl>(D);
9890  if (!VD) {
9891  Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
9892  D->setInvalidDecl();
9893  return;
9894  }
9895 
9896  VD->setCXXForRangeDecl(true);
9897 
9898  // for-range-declaration cannot be given a storage class specifier.
9899  int Error = -1;
9900  switch (VD->getStorageClass()) {
9901  case SC_None:
9902  break;
9903  case SC_Extern:
9904  Error = 0;
9905  break;
9906  case SC_Static:
9907  Error = 1;
9908  break;
9909  case SC_PrivateExtern:
9910  Error = 2;
9911  break;
9912  case SC_Auto:
9913  Error = 3;
9914  break;
9915  case SC_Register:
9916  Error = 4;
9917  break;
9918  }
9919  if (Error != -1) {
9920  Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
9921  << VD->getDeclName() << Error;
9922  D->setInvalidDecl();
9923  }
9924 }
9925 
9926 StmtResult
9928  IdentifierInfo *Ident,
9929  ParsedAttributes &Attrs,
9930  SourceLocation AttrEnd) {
9931  // C++1y [stmt.iter]p1:
9932  // A range-based for statement of the form
9933  // for ( for-range-identifier : for-range-initializer ) statement
9934  // is equivalent to
9935  // for ( auto&& for-range-identifier : for-range-initializer ) statement
9936  DeclSpec DS(Attrs.getPool().getFactory());
9937 
9938  const char *PrevSpec;
9939  unsigned DiagID;
9940  DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
9941  getPrintingPolicy());
9942 
9944  D.SetIdentifier(Ident, IdentLoc);
9945  D.takeAttributes(Attrs, AttrEnd);
9946 
9947  ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
9948  D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false),
9949  EmptyAttrs, IdentLoc);
9950  Decl *Var = ActOnDeclarator(S, D);
9951  cast<VarDecl>(Var)->setCXXForRangeDecl(true);
9952  FinalizeDeclaration(Var);
9953  return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
9954  AttrEnd.isValid() ? AttrEnd : IdentLoc);
9955 }
9956 
9958  if (var->isInvalidDecl()) return;
9959 
9960  // In Objective-C, don't allow jumps past the implicit initialization of a
9961  // local retaining variable.
9962  if (getLangOpts().ObjC1 &&
9963  var->hasLocalStorage()) {
9964  switch (var->getType().getObjCLifetime()) {
9965  case Qualifiers::OCL_None:
9968  break;
9969 
9970  case Qualifiers::OCL_Weak:
9972  getCurFunction()->setHasBranchProtectedScope();
9973  break;
9974  }
9975  }
9976 
9977  // Warn about externally-visible variables being defined without a
9978  // prior declaration. We only want to do this for global
9979  // declarations, but we also specifically need to avoid doing it for
9980  // class members because the linkage of an anonymous class can
9981  // change if it's later given a typedef name.
9982  if (var->isThisDeclarationADefinition() &&
9984  var->isExternallyVisible() && var->hasLinkage() &&
9985  !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
9986  var->getLocation())) {
9987  // Find a previous declaration that's not a definition.
9988  VarDecl *prev = var->getPreviousDecl();
9989  while (prev && prev->isThisDeclarationADefinition())
9990  prev = prev->getPreviousDecl();
9991 
9992  if (!prev)
9993  Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
9994  }
9995 
9996  if (var->getTLSKind() == VarDecl::TLS_Static) {
9997  const Expr *Culprit;
9998  if (var->getType().isDestructedType()) {
9999  // GNU C++98 edits for __thread, [basic.start.term]p3:
10000  // The type of an object with thread storage duration shall not
10001  // have a non-trivial destructor.
10002  Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
10003  if (getLangOpts().CPlusPlus11)
10004  Diag(var->getLocation(), diag::note_use_thread_local);
10005  } else if (getLangOpts().CPlusPlus && var->hasInit() &&
10006  !var->getInit()->isConstantInitializer(
10007  Context, var->getType()->isReferenceType(), &Culprit)) {
10008  // GNU C++98 edits for __thread, [basic.start.init]p4:
10009  // An object of thread storage duration shall not require dynamic
10010  // initialization.
10011  // FIXME: Need strict checking here.
10012  Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init)
10013  << Culprit->getSourceRange();
10014  if (getLangOpts().CPlusPlus11)
10015  Diag(var->getLocation(), diag::note_use_thread_local);
10016  }
10017 
10018  }
10019 
10020  // Apply section attributes and pragmas to global variables.
10021  bool GlobalStorage = var->hasGlobalStorage();
10022  if (GlobalStorage && var->isThisDeclarationADefinition() &&
10023  ActiveTemplateInstantiations.empty()) {
10025  int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read;
10026  if (var->getType().isConstQualified())
10027  Stack = &ConstSegStack;
10028  else if (!var->getInit()) {
10029  Stack = &BSSSegStack;
10030  SectionFlags |= ASTContext::PSF_Write;
10031  } else {
10032  Stack = &DataSegStack;
10033  SectionFlags |= ASTContext::PSF_Write;
10034  }
10035  if (Stack->CurrentValue && !var->hasAttr<SectionAttr>()) {
10036  var->addAttr(SectionAttr::CreateImplicit(
10037  Context, SectionAttr::Declspec_allocate,
10038  Stack->CurrentValue->getString(), Stack->CurrentPragmaLocation));
10039  }
10040  if (const SectionAttr *SA = var->getAttr<SectionAttr>())
10041  if (UnifySection(SA->getName(), SectionFlags, var))
10042  var->dropAttr<SectionAttr>();
10043 
10044  // Apply the init_seg attribute if this has an initializer. If the
10045  // initializer turns out to not be dynamic, we'll end up ignoring this
10046  // attribute.
10047  if (CurInitSeg && var->getInit())
10048  var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
10049  CurInitSegLoc));
10050  }
10051 
10052  // All the following checks are C++ only.
10053  if (!getLangOpts().CPlusPlus) return;
10054 
10055  QualType type = var->getType();
10056  if (type->isDependentType()) return;
10057 
10058  // __block variables might require us to capture a copy-initializer.
10059  if (var->hasAttr<BlocksAttr>()) {
10060  // It's currently invalid to ever have a __block variable with an
10061  // array type; should we diagnose that here?
10062 
10063  // Regardless, we don't want to ignore array nesting when
10064  // constructing this copy.
10065  if (type->isStructureOrClassType()) {
10066  EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
10067  SourceLocation poi = var->getLocation();
10068  Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
10069  ExprResult result
10070  = PerformMoveOrCopyInitialization(
10071  InitializedEntity::InitializeBlock(poi, type, false),
10072  var, var->getType(), varRef, /*AllowNRVO=*/true);
10073  if (!result.isInvalid()) {
10074  result = MaybeCreateExprWithCleanups(result);
10075  Expr *init = result.getAs<Expr>();
10076  Context.setBlockVarCopyInits(var, init);
10077  }
10078  }
10079  }
10080 
10081  Expr *Init = var->getInit();
10082  bool IsGlobal = GlobalStorage && !var->isStaticLocal();
10083  QualType baseType = Context.getBaseElementType(type);
10084 
10085  if (!var->getDeclContext()->isDependentContext() &&
10086  Init && !Init->isValueDependent()) {
10087  if (IsGlobal && !var->isConstexpr() &&
10088  !getDiagnostics().isIgnored(diag::warn_global_constructor,
10089  var->getLocation())) {
10090  // Warn about globals which don't have a constant initializer. Don't
10091  // warn about globals with a non-trivial destructor because we already
10092  // warned about them.
10093  CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
10094  if (!(RD && !RD->hasTrivialDestructor()) &&
10095  !Init->isConstantInitializer(Context, baseType->isReferenceType()))
10096  Diag(var->getLocation(), diag::warn_global_constructor)
10097  << Init->getSourceRange();
10098  }
10099 
10100  if (var->isConstexpr()) {
10102  if (!var->evaluateValue(Notes) || !var->isInitICE()) {
10103  SourceLocation DiagLoc = var->getLocation();
10104  // If the note doesn't add any useful information other than a source
10105  // location, fold it into the primary diagnostic.
10106  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
10107  diag::note_invalid_subexpr_in_const_expr) {
10108  DiagLoc = Notes[0].first;
10109  Notes.clear();
10110  }
10111  Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
10112  << var << Init->getSourceRange();
10113  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
10114  Diag(Notes[I].first, Notes[I].second);
10115  }
10116  } else if (var->isUsableInConstantExpressions(Context)) {
10117  // Check whether the initializer of a const variable of integral or
10118  // enumeration type is an ICE now, since we can't tell whether it was
10119  // initialized by a constant expression if we check later.
10120  var->checkInitIsICE();
10121  }
10122  }
10123 
10124  // Require the destructor.
10125  if (const RecordType *recordType = baseType->getAs<RecordType>())
10126  FinalizeVarWithDestructor(var, recordType);
10127 }
10128 
10129 /// \brief Determines if a variable's alignment is dependent.
10130 static bool hasDependentAlignment(VarDecl *VD) {
10131  if (VD->getType()->isDependentType())
10132  return true;
10133  for (auto *I : VD->specific_attrs<AlignedAttr>())
10134  if (I->isAlignmentDependent())
10135  return true;
10136  return false;
10137 }
10138 
10139 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
10140 /// any semantic actions necessary after any initializer has been attached.
10141 void
10143  // Note that we are no longer parsing the initializer for this declaration.
10144  ParsingInitForAutoVars.erase(ThisDecl);
10145 
10146  VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
10147  if (!VD)
10148  return;
10149 
10150  checkAttributesAfterMerging(*this, *VD);
10151 
10152  // Perform TLS alignment check here after attributes attached to the variable
10153  // which may affect the alignment have been processed. Only perform the check
10154  // if the target has a maximum TLS alignment (zero means no constraints).
10155  if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) {
10156  // Protect the check so that it's not performed on dependent types and
10157  // dependent alignments (we can't determine the alignment in that case).
10158  if (VD->getTLSKind() && !hasDependentAlignment(VD)) {
10159  CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
10160  if (Context.getDeclAlign(VD) > MaxAlignChars) {
10161  Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
10162  << (unsigned)Context.getDeclAlign(VD).getQuantity() << VD
10163  << (unsigned)MaxAlignChars.getQuantity();
10164  }
10165  }
10166  }
10167 
10168  // Static locals inherit dll attributes from their function.
10169  if (VD->isStaticLocal()) {
10170  if (FunctionDecl *FD =
10171  dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
10172  if (Attr *A = getDLLAttr(FD)) {
10173  auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
10174  NewAttr->setInherited(true);
10175  VD->addAttr(NewAttr);
10176  }
10177  }
10178  }
10179 
10180  // Grab the dllimport or dllexport attribute off of the VarDecl.
10181  const InheritableAttr *DLLAttr = getDLLAttr(VD);
10182 
10183  // Imported static data members cannot be defined out-of-line.
10184  if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
10185  if (VD->isStaticDataMember() && VD->isOutOfLine() &&
10187  // We allow definitions of dllimport class template static data members
10188  // with a warning.
10190  cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
10191  bool IsClassTemplateMember =
10192  isa<ClassTemplatePartialSpecializationDecl>(Context) ||
10193  Context->getDescribedClassTemplate();
10194 
10195  Diag(VD->getLocation(),
10196  IsClassTemplateMember
10197  ? diag::warn_attribute_dllimport_static_field_definition
10198  : diag::err_attribute_dllimport_static_field_definition);
10199  Diag(IA->getLocation(), diag::note_attribute);
10200  if (!IsClassTemplateMember)
10201  VD->setInvalidDecl();
10202  }
10203  }
10204 
10205  // dllimport/dllexport variables cannot be thread local, their TLS index
10206  // isn't exported with the variable.
10207  if (DLLAttr && VD->getTLSKind()) {
10208  auto *F = dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod());
10209  if (F && getDLLAttr(F)) {
10210  assert(VD->isStaticLocal());
10211  // But if this is a static local in a dlimport/dllexport function, the
10212  // function will never be inlined, which means the var would never be
10213  // imported, so having it marked import/export is safe.
10214  } else {
10215  Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
10216  << DLLAttr;
10217  VD->setInvalidDecl();
10218  }
10219  }
10220 
10221  if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
10222  if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
10223  Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
10224  VD->dropAttr<UsedAttr>();
10225  }
10226  }
10227 
10228  const DeclContext *DC = VD->getDeclContext();
10229  // If there's a #pragma GCC visibility in scope, and this isn't a class
10230  // member, set the visibility of this variable.
10231  if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
10232  AddPushedVisibilityAttribute(VD);
10233 
10234  // FIXME: Warn on unused templates.
10235  if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() &&
10236  !isa<VarTemplatePartialSpecializationDecl>(VD))
10237  MarkUnusedFileScopedDecl(VD);
10238 
10239  // Now we have parsed the initializer and can update the table of magic
10240  // tag values.
10241  if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
10243  return;
10244 
10245  for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
10246  const Expr *MagicValueExpr = VD->getInit();
10247  if (!MagicValueExpr) {
10248  continue;
10249  }
10250  llvm::APSInt MagicValueInt;
10251  if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
10252  Diag(I->getRange().getBegin(),
10253  diag::err_type_tag_for_datatype_not_ice)
10254  << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
10255  continue;
10256  }
10257  if (MagicValueInt.getActiveBits() > 64) {
10258  Diag(I->getRange().getBegin(),
10259  diag::err_type_tag_for_datatype_too_large)
10260  << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
10261  continue;
10262  }
10263  uint64_t MagicValue = MagicValueInt.getZExtValue();
10264  RegisterTypeTagForDatatype(I->getArgumentKind(),
10265  MagicValue,
10266  I->getMatchingCType(),
10267  I->getLayoutCompatible(),
10268  I->getMustBeNull());
10269  }
10270 }
10271 
10273  ArrayRef<Decl *> Group) {
10274  SmallVector<Decl*, 8> Decls;
10275 
10276  if (DS.isTypeSpecOwned())
10277  Decls.push_back(DS.getRepAsDecl());
10278 
10279  DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
10280  for (unsigned i = 0, e = Group.size(); i != e; ++i)
10281  if (Decl *D = Group[i]) {
10282  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
10283  if (!FirstDeclaratorInGroup)
10284  FirstDeclaratorInGroup = DD;
10285  Decls.push_back(D);
10286  }
10287 
10289  if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
10290  handleTagNumbering(Tag, S);
10291  if (FirstDeclaratorInGroup && !Tag->hasNameForLinkage() &&
10292  getLangOpts().CPlusPlus)
10293  Context.addDeclaratorForUnnamedTagDecl(Tag, FirstDeclaratorInGroup);
10294  }
10295  }
10296 
10297  return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType());
10298 }
10299 
10300 /// BuildDeclaratorGroup - convert a list of declarations into a declaration
10301 /// group, performing any necessary semantic checking.
10304  bool TypeMayContainAuto) {
10305  // C++0x [dcl.spec.auto]p7:
10306  // If the type deduced for the template parameter U is not the same in each
10307  // deduction, the program is ill-formed.
10308  // FIXME: When initializer-list support is added, a distinction is needed
10309  // between the deduced type U and the deduced type which 'auto' stands for.
10310  // auto a = 0, b = { 1, 2, 3 };
10311  // is legal because the deduced type U is 'int' in both cases.
10312  if (TypeMayContainAuto && Group.size() > 1) {
10313  QualType Deduced;
10314  CanQualType DeducedCanon;
10315  VarDecl *DeducedDecl = nullptr;
10316  for (unsigned i = 0, e = Group.size(); i != e; ++i) {
10317  if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
10318  AutoType *AT = D->getType()->getContainedAutoType();
10319  // Don't reissue diagnostics when instantiating a template.
10320  if (AT && D->isInvalidDecl())
10321  break;
10322  QualType U = AT ? AT->getDeducedType() : QualType();
10323  if (!U.isNull()) {
10324  CanQualType UCanon = Context.getCanonicalType(U);
10325  if (Deduced.isNull()) {
10326  Deduced = U;
10327  DeducedCanon = UCanon;
10328  DeducedDecl = D;
10329  } else if (DeducedCanon != UCanon) {
10330  Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
10331  diag::err_auto_different_deductions)
10332  << (unsigned)AT->getKeyword()
10333  << Deduced << DeducedDecl->getDeclName()
10334  << U << D->getDeclName()
10335  << DeducedDecl->getInit()->getSourceRange()
10336  << D->getInit()->getSourceRange();
10337  D->setInvalidDecl();
10338  break;
10339  }
10340  }
10341  }
10342  }
10343  }
10344 
10345  ActOnDocumentableDecls(Group);
10346 
10347  return DeclGroupPtrTy::make(
10348  DeclGroupRef::Create(Context, Group.data(), Group.size()));
10349 }
10350 
10352  ActOnDocumentableDecls(D);
10353 }
10354 
10356  // Don't parse the comment if Doxygen diagnostics are ignored.
10357  if (Group.empty() || !Group[0])
10358  return;
10359 
10360  if (Diags.isIgnored(diag::warn_doc_param_not_found,
10361  Group[0]->getLocation()) &&
10362  Diags.isIgnored(diag::warn_unknown_comment_command_name,
10363  Group[0]->getLocation()))
10364  return;
10365 
10366  if (Group.size() >= 2) {
10367  // This is a decl group. Normally it will contain only declarations
10368  // produced from declarator list. But in case we have any definitions or
10369  // additional declaration references:
10370  // 'typedef struct S {} S;'
10371  // 'typedef struct S *S;'
10372  // 'struct S *pS;'
10373  // FinalizeDeclaratorGroup adds these as separate declarations.
10374  Decl *MaybeTagDecl = Group[0];
10375  if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
10376  Group = Group.slice(1);
10377  }
10378  }
10379 
10380  // See if there are any new comments that are not attached to a decl.
10382  if (!Comments.empty() &&
10383  !Comments.back()->isAttached()) {
10384  // There is at least one comment that not attached to a decl.
10385  // Maybe it should be attached to one of these decls?
10386  //
10387  // Note that this way we pick up not only comments that precede the
10388  // declaration, but also comments that *follow* the declaration -- thanks to
10389  // the lookahead in the lexer: we've consumed the semicolon and looked
10390  // ahead through comments.
10391  for (unsigned i = 0, e = Group.size(); i != e; ++i)
10392  Context.getCommentForDecl(Group[i], &PP);
10393  }
10394 }
10395 
10396 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
10397 /// to introduce parameters into function prototype scope.
10399  const DeclSpec &DS = D.getDeclSpec();
10400 
10401  // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
10402 
10403  // C++03 [dcl.stc]p2 also permits 'auto'.
10404  StorageClass SC = SC_None;
10406  SC = SC_Register;
10407  } else if (getLangOpts().CPlusPlus &&
10409  SC = SC_Auto;
10410  } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
10412  diag::err_invalid_storage_class_in_func_decl);
10414  }
10415 
10416  if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
10417  Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
10418  << DeclSpec::getSpecifierName(TSCS);
10419  if (DS.isConstexprSpecified())
10420  Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
10421  << 0;
10422  if (DS.isConceptSpecified())
10423  Diag(DS.getConceptSpecLoc(), diag::err_concept_wrong_decl_kind);
10424 
10425  DiagnoseFunctionSpecifiers(DS);
10426 
10427  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
10428  QualType parmDeclType = TInfo->getType();
10429 
10430  if (getLangOpts().CPlusPlus) {
10431  // Check that there are no default arguments inside the type of this
10432  // parameter.
10433  CheckExtraCXXDefaultArguments(D);
10434 
10435  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
10436  if (D.getCXXScopeSpec().isSet()) {
10437  Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
10438  << D.getCXXScopeSpec().getRange();
10439  D.getCXXScopeSpec().clear();
10440  }
10441  }
10442 
10443  // Ensure we have a valid name
10444  IdentifierInfo *II = nullptr;
10445  if (D.hasName()) {
10446  II = D.getIdentifier();
10447  if (!II) {
10448  Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
10449  << GetNameForDeclarator(D).getName();
10450  D.setInvalidType(true);
10451  }
10452  }
10453 
10454  // Check for redeclaration of parameters, e.g. int foo(int x, int x);
10455  if (II) {
10456  LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
10457  ForRedeclaration);
10458  LookupName(R, S);
10459  if (R.isSingleResult()) {
10460  NamedDecl *PrevDecl = R.getFoundDecl();
10461  if (PrevDecl->isTemplateParameter()) {
10462  // Maybe we will complain about the shadowed template parameter.
10463  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
10464  // Just pretend that we didn't see the previous declaration.
10465  PrevDecl = nullptr;
10466  } else if (S->isDeclScope(PrevDecl)) {
10467  Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
10468  Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
10469 
10470  // Recover by removing the name
10471  II = nullptr;
10472  D.SetIdentifier(nullptr, D.getIdentifierLoc());
10473  D.setInvalidType(true);
10474  }
10475  }
10476  }
10477 
10478  // Temporarily put parameter variables in the translation unit, not
10479  // the enclosing context. This prevents them from accidentally
10480  // looking like class members in C++.
10481  ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
10482  D.getLocStart(),
10483  D.getIdentifierLoc(), II,
10484  parmDeclType, TInfo,
10485  SC);
10486 
10487  if (D.isInvalidType())
10488  New->setInvalidDecl();
10489 
10490  assert(S->isFunctionPrototypeScope());
10491  assert(S->getFunctionPrototypeDepth() >= 1);
10494 
10495  // Add the parameter declaration into this scope.
10496  S->AddDecl(New);
10497  if (II)
10498  IdResolver.AddDecl(New);
10499 
10500  ProcessDeclAttributes(S, New, D);
10501 
10503  Diag(New->getLocation(), diag::err_module_private_local)
10504  << 1 << New->getDeclName()
10507 
10508  if (New->hasAttr<BlocksAttr>()) {
10509  Diag(New->getLocation(), diag::err_block_on_nonlocal);
10510  }
10511  return New;
10512 }
10513 
10514 /// \brief Synthesizes a variable for a parameter arising from a
10515 /// typedef.
10517  SourceLocation Loc,
10518  QualType T) {
10519  /* FIXME: setting StartLoc == Loc.
10520  Would it be worth to modify callers so as to provide proper source
10521  location for the unnamed parameters, embedding the parameter's type? */
10522  ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
10523  T, Context.getTrivialTypeSourceInfo(T, Loc),
10524  SC_None, nullptr);
10525  Param->setImplicit();
10526  return Param;
10527 }
10528 
10530  ParmVarDecl * const *ParamEnd) {
10531  // Don't diagnose unused-parameter errors in template instantiations; we
10532  // will already have done so in the template itself.
10533  if (!ActiveTemplateInstantiations.empty())
10534  return;
10535 
10536  for (; Param != ParamEnd; ++Param) {
10537  if (!(*Param)->isReferenced() && (*Param)->getDeclName() &&
10538  !(*Param)->hasAttr<UnusedAttr>()) {
10539  Diag((*Param)->getLocation(), diag::warn_unused_parameter)
10540  << (*Param)->getDeclName();
10541  }
10542  }
10543 }
10544 
10546  ParmVarDecl * const *ParamEnd,
10547  QualType ReturnTy,
10548  NamedDecl *D) {
10549  if (LangOpts.NumLargeByValueCopy == 0) // No check.
10550  return;
10551 
10552  // Warn if the return value is pass-by-value and larger than the specified
10553  // threshold.
10554  if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
10555  unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
10556  if (Size > LangOpts.NumLargeByValueCopy)
10557  Diag(D->getLocation(), diag::warn_return_value_size)
10558  << D->getDeclName() << Size;
10559  }
10560 
10561  // Warn if any parameter is pass-by-value and larger than the specified
10562  // threshold.
10563  for (; Param != ParamEnd; ++Param) {
10564  QualType T = (*Param)->getType();
10565  if (T->isDependentType() || !T.isPODType(Context))
10566  continue;
10567  unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
10568  if (Size > LangOpts.NumLargeByValueCopy)
10569  Diag((*Param)->getLocation(), diag::warn_parameter_size)
10570  << (*Param)->getDeclName() << Size;
10571  }
10572 }
10573 
10575  SourceLocation NameLoc, IdentifierInfo *Name,
10576  QualType T, TypeSourceInfo *TSInfo,
10577  StorageClass SC) {
10578  // In ARC, infer a lifetime qualifier for appropriate parameter types.
10579  if (getLangOpts().ObjCAutoRefCount &&
10581  T->isObjCLifetimeType()) {
10582 
10583  Qualifiers::ObjCLifetime lifetime;
10584 
10585  // Special cases for arrays:
10586  // - if it's const, use __unsafe_unretained
10587  // - otherwise, it's an error
10588  if (T->isArrayType()) {
10589  if (!T.isConstQualified()) {
10592  NameLoc, diag::err_arc_array_param_no_ownership, T, false));
10593  }
10594  lifetime = Qualifiers::OCL_ExplicitNone;
10595  } else {
10596  lifetime = T->getObjCARCImplicitLifetime();
10597  }
10598  T = Context.getLifetimeQualifiedType(T, lifetime);
10599  }
10600 
10601  ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
10603  TSInfo, SC, nullptr);
10604 
10605  // Parameters can not be abstract class types.
10606  // For record types, this is done by the AbstractClassUsageDiagnoser once
10607  // the class has been completely parsed.
10608  if (!CurContext->isRecord() &&
10609  RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
10610  AbstractParamType))
10611  New->setInvalidDecl();
10612 
10613  // Parameter declarators cannot be interface types. All ObjC objects are
10614  // passed by reference.
10615  if (T->isObjCObjectType()) {
10616  SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd();
10617  Diag(NameLoc,
10618  diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
10619  << FixItHint::CreateInsertion(TypeEndLoc, "*");
10621  New->setType(T);
10622  }
10623 
10624  // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
10625  // duration shall not be qualified by an address-space qualifier."
10626  // Since all parameters have automatic store duration, they can not have
10627  // an address space.
10628  if (T.getAddressSpace() != 0) {
10629  // OpenCL allows function arguments declared to be an array of a type
10630  // to be qualified with an address space.
10631  if (!(getLangOpts().OpenCL && T->isArrayType())) {
10632  Diag(NameLoc, diag::err_arg_with_address_space);
10633  New->setInvalidDecl();
10634  }
10635  }
10636 
10637  return New;
10638 }
10639 
10641  SourceLocation LocAfterDecls) {
10643 
10644  // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
10645  // for a K&R function.
10646  if (!FTI.hasPrototype) {
10647  for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
10648  --i;
10649  if (FTI.Params[i].Param == nullptr) {
10650  SmallString<256> Code;
10651  llvm::raw_svector_ostream(Code)
10652  << " int " << FTI.Params[i].Ident->getName() << ";\n";
10653  Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
10654  << FTI.Params[i].Ident
10655  << FixItHint::CreateInsertion(LocAfterDecls, Code);
10656 
10657  // Implicitly declare the argument as type 'int' for lack of a better
10658  // type.
10659  AttributeFactory attrs;
10660  DeclSpec DS(attrs);
10661  const char* PrevSpec; // unused
10662  unsigned DiagID; // unused
10663  DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
10664  DiagID, Context.getPrintingPolicy());
10665  // Use the identifier location for the type source range.
10666  DS.SetRangeStart(FTI.Params[i].IdentLoc);
10667  DS.SetRangeEnd(FTI.Params[i].IdentLoc);
10669  ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
10670  FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
10671  }
10672  }
10673  }
10674 }
10675 
10676 Decl *
10678  MultiTemplateParamsArg TemplateParameterLists,
10679  SkipBodyInfo *SkipBody) {
10680  assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
10681  assert(D.isFunctionDeclarator() && "Not a function declarator!");
10682  Scope *ParentScope = FnBodyScope->getParent();
10683 
10685  Decl *DP = HandleDeclarator(ParentScope, D, TemplateParameterLists);
10686  return ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody);
10687 }
10688 
10690  Consumer.HandleInlineMethodDefinition(D);
10691 }
10692 
10694  const FunctionDecl*& PossibleZeroParamPrototype) {
10695  // Don't warn about invalid declarations.
10696  if (FD->isInvalidDecl())
10697  return false;
10698 
10699  // Or declarations that aren't global.
10700  if (!FD->isGlobal())
10701  return false;
10702 
10703  // Don't warn about C++ member functions.
10704  if (isa<CXXMethodDecl>(FD))
10705  return false;
10706 
10707  // Don't warn about 'main'.
10708  if (FD->isMain())
10709  return false;
10710 
10711  // Don't warn about inline functions.
10712  if (FD->isInlined())
10713  return false;
10714 
10715  // Don't warn about function templates.
10716  if (FD->getDescribedFunctionTemplate())
10717  return false;
10718 
10719  // Don't warn about function template specializations.
10721  return false;
10722 
10723  // Don't warn for OpenCL kernels.
10724  if (FD->hasAttr<OpenCLKernelAttr>())
10725  return false;
10726 
10727  // Don't warn on explicitly deleted functions.
10728  if (FD->isDeleted())
10729  return false;
10730 
10731  bool MissingPrototype = true;
10732  for (const FunctionDecl *Prev = FD->getPreviousDecl();
10733  Prev; Prev = Prev->getPreviousDecl()) {
10734  // Ignore any declarations that occur in function or method
10735  // scope, because they aren't visible from the header.
10736  if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
10737  continue;
10738 
10739  MissingPrototype = !Prev->getType()->isFunctionProtoType();
10740  if (FD->getNumParams() == 0)
10741  PossibleZeroParamPrototype = Prev;
10742  break;
10743  }
10744 
10745  return MissingPrototype;
10746 }
10747 
10748 void
10750  const FunctionDecl *EffectiveDefinition,
10751  SkipBodyInfo *SkipBody) {
10752  // Don't complain if we're in GNU89 mode and the previous definition
10753  // was an extern inline function.
10754  const FunctionDecl *Definition = EffectiveDefinition;
10755  if (!Definition)
10756  if (!FD->isDefined(Definition))
10757  return;
10758 
10759  if (canRedefineFunction(Definition, getLangOpts()))
10760  return;
10761 
10762  // If we don't have a visible definition of the function, and it's inline or
10763  // a template, skip the new definition.
10764  if (SkipBody && !hasVisibleDefinition(Definition) &&
10765  (Definition->getFormalLinkage() == InternalLinkage ||
10766  Definition->isInlined() ||
10767  Definition->getDescribedFunctionTemplate() ||
10768  Definition->getNumTemplateParameterLists())) {
10769  SkipBody->ShouldSkip = true;
10770  if (auto *TD = Definition->getDescribedFunctionTemplate())
10771  makeMergedDefinitionVisible(TD, FD->getLocation());
10772  else
10773  makeMergedDefinitionVisible(const_cast<FunctionDecl*>(Definition),
10774  FD->getLocation());
10775  return;
10776  }
10777 
10778  if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
10779  Definition->getStorageClass() == SC_Extern)
10780  Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
10781  << FD->getDeclName() << getLangOpts().CPlusPlus;
10782  else
10783  Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
10784 
10785  Diag(Definition->getLocation(), diag::note_previous_definition);
10786  FD->setInvalidDecl();
10787 }
10788 
10789 
10790 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
10791  Sema &S) {
10792  CXXRecordDecl *const LambdaClass = CallOperator->getParent();
10793 
10794  LambdaScopeInfo *LSI = S.PushLambdaScope();
10795  LSI->CallOperator = CallOperator;
10796  LSI->Lambda = LambdaClass;
10797  LSI->ReturnType = CallOperator->getReturnType();
10798  const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
10799 
10800  if (LCD == LCD_None)
10802  else if (LCD == LCD_ByCopy)
10804  else if (LCD == LCD_ByRef)
10806  DeclarationNameInfo DNI = CallOperator->getNameInfo();
10807 
10809  LSI->Mutable = !CallOperator->isConst();
10810 
10811  // Add the captures to the LSI so they can be noted as already
10812  // captured within tryCaptureVar.
10813  auto I = LambdaClass->field_begin();
10814  for (const auto &C : LambdaClass->captures()) {
10815  if (C.capturesVariable()) {
10816  VarDecl *VD = C.getCapturedVar();
10817  if (VD->isInitCapture())
10819  QualType CaptureType = VD->getType();
10820  const bool ByRef = C.getCaptureKind() == LCK_ByRef;
10821  LSI->addCapture(VD, /*IsBlock*/false, ByRef,
10822  /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
10823  /*EllipsisLoc*/C.isPackExpansion()
10824  ? C.getEllipsisLoc() : SourceLocation(),
10825  CaptureType, /*Expr*/ nullptr);
10826 
10827  } else if (C.capturesThis()) {
10828  LSI->addThisCapture(/*Nested*/ false, C.getLocation(),
10829  S.getCurrentThisType(), /*Expr*/ nullptr);
10830  } else {
10831  LSI->addVLATypeCapture(C.getLocation(), I->getType());
10832  }
10833  ++I;
10834  }
10835 }
10836 
10838  SkipBodyInfo *SkipBody) {
10839  // Clear the last template instantiation error context.
10840  LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
10841 
10842  if (!D)
10843  return D;
10844  FunctionDecl *FD = nullptr;
10845 
10846  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
10847  FD = FunTmpl->getTemplatedDecl();
10848  else
10849  FD = cast<FunctionDecl>(D);
10850 
10851  // See if this is a redefinition.
10852  if (!FD->isLateTemplateParsed()) {
10853  CheckForFunctionRedefinition(FD, nullptr, SkipBody);
10854 
10855  // If we're skipping the body, we're done. Don't enter the scope.
10856  if (SkipBody && SkipBody->ShouldSkip)
10857  return D;
10858  }
10859 
10860  // If we are instantiating a generic lambda call operator, push
10861  // a LambdaScopeInfo onto the function stack. But use the information
10862  // that's already been calculated (ActOnLambdaExpr) to prime the current
10863  // LambdaScopeInfo.
10864  // When the template operator is being specialized, the LambdaScopeInfo,
10865  // has to be properly restored so that tryCaptureVariable doesn't try
10866  // and capture any new variables. In addition when calculating potential
10867  // captures during transformation of nested lambdas, it is necessary to
10868  // have the LSI properly restored.
10870  assert(ActiveTemplateInstantiations.size() &&
10871  "There should be an active template instantiation on the stack "
10872  "when instantiating a generic lambda!");
10873  RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
10874  }
10875  else
10876  // Enter a new function scope
10877  PushFunctionScope();
10878 
10879  // Builtin functions cannot be defined.
10880  if (unsigned BuiltinID = FD->getBuiltinID()) {
10881  if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
10883  Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
10884  FD->setInvalidDecl();
10885  }
10886  }
10887 
10888  // The return type of a function definition must be complete
10889  // (C99 6.9.1p3, C++ [dcl.fct]p6).
10890  QualType ResultType = FD->getReturnType();
10891  if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
10892  !FD->isInvalidDecl() &&
10893  RequireCompleteType(FD->getLocation(), ResultType,
10894  diag::err_func_def_incomplete_result))
10895  FD->setInvalidDecl();
10896 
10897  if (FnBodyScope)
10898  PushDeclContext(FnBodyScope, FD);
10899 
10900  // Check the validity of our function parameters
10901  CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
10902  /*CheckParameterNames=*/true);
10903 
10904  // Introduce our parameters into the function scope
10905  for (auto Param : FD->params()) {
10906  Param->setOwningFunction(FD);
10907 
10908  // If this has an identifier, add it to the scope stack.
10909  if (Param->getIdentifier() && FnBodyScope) {
10910  CheckShadow(FnBodyScope, Param);
10911 
10912  PushOnScopeChains(Param, FnBodyScope);
10913  }
10914  }
10915 
10916  // If we had any tags defined in the function prototype,
10917  // introduce them into the function scope.
10918  if (FnBodyScope) {
10920  I = FD->getDeclsInPrototypeScope().begin(),
10921  E = FD->getDeclsInPrototypeScope().end();
10922  I != E; ++I) {
10923  NamedDecl *D = *I;
10924 
10925  // Some of these decls (like enums) may have been pinned to the
10926  // translation unit for lack of a real context earlier. If so, remove
10927  // from the translation unit and reattach to the current context.
10929  // Is the decl actually in the context?
10932  // Either way, reassign the lexical decl context to our FunctionDecl.
10933  D->setLexicalDeclContext(CurContext);
10934  }
10935 
10936  // If the decl has a non-null name, make accessible in the current scope.
10937  if (!D->getName().empty())
10938  PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
10939 
10940  // Similarly, dive into enums and fish their constants out, making them
10941  // accessible in this scope.
10942  if (auto *ED = dyn_cast<EnumDecl>(D)) {
10943  for (auto *EI : ED->enumerators())
10944  PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
10945  }
10946  }
10947  }
10948 
10949  // Ensure that the function's exception specification is instantiated.
10950  if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
10951  ResolveExceptionSpec(D->getLocation(), FPT);
10952 
10953  // dllimport cannot be applied to non-inline function definitions.
10954  if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
10955  !FD->isTemplateInstantiation()) {
10956  assert(!FD->hasAttr<DLLExportAttr>());
10957  Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
10958  FD->setInvalidDecl();
10959  return D;
10960  }
10961  // We want to attach documentation to original Decl (which might be
10962  // a function template).
10963  ActOnDocumentableDecl(D);
10964  if (getCurLexicalContext()->isObjCContainer() &&
10965  getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
10966  getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
10967  Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
10968 
10969  return D;
10970 }
10971 
10972 /// \brief Given the set of return statements within a function body,
10973 /// compute the variables that are subject to the named return value
10974 /// optimization.
10975 ///
10976 /// Each of the variables that is subject to the named return value
10977 /// optimization will be marked as NRVO variables in the AST, and any
10978 /// return statement that has a marked NRVO variable as its NRVO candidate can
10979 /// use the named return value optimization.
10980 ///
10981 /// This function applies a very simplistic algorithm for NRVO: if every return
10982 /// statement in the scope of a variable has the same NRVO candidate, that
10983 /// candidate is an NRVO variable.
10985  ReturnStmt **Returns = Scope->Returns.data();
10986 
10987  for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
10988  if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
10989  if (!NRVOCandidate->isNRVOVariable())
10990  Returns[I]->setNRVOCandidate(nullptr);
10991  }
10992  }
10993 }
10994 
10996  // We can't delay parsing the body of a constexpr function template (yet).
10998  return false;
10999 
11000  // We can't delay parsing the body of a function template with a deduced
11001  // return type (yet).
11003  // If the placeholder introduces a non-deduced trailing return type,
11004  // we can still delay parsing it.
11005  if (D.getNumTypeObjects()) {
11006  const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
11007  if (Outer.Kind == DeclaratorChunk::Function &&
11008  Outer.Fun.hasTrailingReturnType()) {
11009  QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
11010  return Ty.isNull() || !Ty->isUndeducedType();
11011  }
11012  }
11013  return false;
11014  }
11015 
11016  return true;
11017 }
11018 
11020  // We cannot skip the body of a function (or function template) which is
11021  // constexpr, since we may need to evaluate its body in order to parse the
11022  // rest of the file.
11023  // We cannot skip the body of a function with an undeduced return type,
11024  // because any callers of that function need to know the type.
11025  if (const FunctionDecl *FD = D->getAsFunction())
11026  if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
11027  return false;
11028  return Consumer.shouldSkipFunctionBody(D);
11029 }
11030 
11032  if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
11033  FD->setHasSkippedBody();
11034  else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
11035  MD->setHasSkippedBody();
11036  return ActOnFinishFunctionBody(Decl, nullptr);
11037 }
11038 
11040  return ActOnFinishFunctionBody(D, BodyArg, false);
11041 }
11042 
11044  bool IsInstantiation) {
11045  FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
11046 
11047  sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
11048  sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
11049 
11050  if (getLangOpts().Coroutines && !getCurFunction()->CoroutineStmts.empty())
11051  CheckCompletedCoroutineBody(FD, Body);
11052 
11053  if (FD) {
11054  FD->setBody(Body);
11055 
11056  if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body &&
11057  !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) {
11058  // If the function has a deduced result type but contains no 'return'
11059  // statements, the result type as written must be exactly 'auto', and
11060  // the deduced result type is 'void'.
11061  if (!FD->getReturnType()->getAs<AutoType>()) {
11062  Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
11063  << FD->getReturnType();
11064  FD->setInvalidDecl();
11065  } else {
11066  // Substitute 'void' for the 'auto' in the type.
11067  TypeLoc ResultType = getReturnTypeLoc(FD);
11069  FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
11070  }
11071  } else if (getLangOpts().CPlusPlus11 && isLambdaCallOperator(FD)) {
11072  auto *LSI = getCurLambda();
11073  if (LSI->HasImplicitReturnType) {
11074  deduceClosureReturnType(*LSI);
11075 
11076  // C++11 [expr.prim.lambda]p4:
11077  // [...] if there are no return statements in the compound-statement
11078  // [the deduced type is] the type void
11079  QualType RetType =
11080  LSI->ReturnType.isNull() ? Context.VoidTy : LSI->ReturnType;
11081 
11082  // Update the return type to the deduced type.
11083  const FunctionProtoType *Proto =
11084  FD->getType()->getAs<FunctionProtoType>();
11085  FD->setType(Context.getFunctionType(RetType, Proto->getParamTypes(),
11086  Proto->getExtProtoInfo()));
11087  }
11088  }
11089 
11090  // The only way to be included in UndefinedButUsed is if there is an
11091  // ODR use before the definition. Avoid the expensive map lookup if this
11092  // is the first declaration.
11093  if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) {
11094  if (!FD->isExternallyVisible())
11095  UndefinedButUsed.erase(FD);
11096  else if (FD->isInlined() &&
11097  !LangOpts.GNUInline &&
11098  (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
11099  UndefinedButUsed.erase(FD);
11100  }
11101 
11102  // If the function implicitly returns zero (like 'main') or is naked,
11103  // don't complain about missing return statements.
11104  if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
11106 
11107  // MSVC permits the use of pure specifier (=0) on function definition,
11108  // defined at class scope, warn about this non-standard construct.
11109  if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
11110  Diag(FD->getLocation(), diag::ext_pure_function_definition);
11111 
11112  if (!FD->isInvalidDecl()) {
11113  // Don't diagnose unused parameters of defaulted or deleted functions.
11114  if (!FD->isDeleted() && !FD->isDefaulted())
11115  DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
11116  DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
11117  FD->getReturnType(), FD);
11118 
11119  // If this is a structor, we need a vtable.
11120  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
11121  MarkVTableUsed(FD->getLocation(), Constructor->getParent());
11122  else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD))
11123  MarkVTableUsed(FD->getLocation(), Destructor->getParent());
11124 
11125  // Try to apply the named return value optimization. We have to check
11126  // if we can do this here because lambdas keep return statements around
11127  // to deduce an implicit return type.
11128  if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
11129  !FD->isDependentContext())
11130  computeNRVO(Body, getCurFunction());
11131  }
11132 
11133  // GNU warning -Wmissing-prototypes:
11134  // Warn if a global function is defined without a previous
11135  // prototype declaration. This warning is issued even if the
11136  // definition itself provides a prototype. The aim is to detect
11137  // global functions that fail to be declared in header files.
11138  const FunctionDecl *PossibleZeroParamPrototype = nullptr;
11139  if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
11140  Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
11141 
11142  if (PossibleZeroParamPrototype) {
11143  // We found a declaration that is not a prototype,
11144  // but that could be a zero-parameter prototype
11145  if (TypeSourceInfo *TI =
11146  PossibleZeroParamPrototype->getTypeSourceInfo()) {
11147  TypeLoc TL = TI->getTypeLoc();
11149  Diag(PossibleZeroParamPrototype->getLocation(),
11150  diag::note_declaration_not_a_prototype)
11151  << PossibleZeroParamPrototype
11152  << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
11153  }
11154  }
11155  }
11156 
11157  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
11158  const CXXMethodDecl *KeyFunction;
11159  if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) &&
11160  MD->isVirtual() &&
11161  (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) &&
11162  MD == KeyFunction->getCanonicalDecl()) {
11163  // Update the key-function state if necessary for this ABI.
11164  if (FD->isInlined() &&
11167 
11168  // If the newly-chosen key function is already defined, then we
11169  // need to mark the vtable as used retroactively.
11170  KeyFunction = Context.getCurrentKeyFunction(MD->getParent());
11171  const FunctionDecl *Definition;
11172  if (KeyFunction && KeyFunction->isDefined(Definition))
11173  MarkVTableUsed(Definition->getLocation(), MD->getParent(), true);
11174  } else {
11175  // We just defined they key function; mark the vtable as used.
11176  MarkVTableUsed(FD->getLocation(), MD->getParent(), true);
11177  }
11178  }
11179  }
11180 
11181  assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
11182  "Function parsing confused");
11183  } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
11184  assert(MD == getCurMethodDecl() && "Method parsing confused");
11185  MD->setBody(Body);
11186  if (!MD->isInvalidDecl()) {
11187  DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
11188  DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
11189  MD->getReturnType(), MD);
11190 
11191  if (Body)
11192  computeNRVO(Body, getCurFunction());
11193  }
11194  if (getCurFunction()->ObjCShouldCallSuper) {
11195  Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
11196  << MD->getSelector().getAsString();
11197  getCurFunction()->ObjCShouldCallSuper = false;
11198  }
11199  if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
11200  const ObjCMethodDecl *InitMethod = nullptr;
11201  bool isDesignated =
11202  MD->isDesignatedInitializerForTheInterface(&InitMethod);
11203  assert(isDesignated && InitMethod);
11204  (void)isDesignated;
11205 
11206  auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
11207  auto IFace = MD->getClassInterface();
11208  if (!IFace)
11209  return false;
11210  auto SuperD = IFace->getSuperClass();
11211  if (!SuperD)
11212  return false;
11213  return SuperD->getIdentifier() ==
11214  NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
11215  };
11216  // Don't issue this warning for unavailable inits or direct subclasses
11217  // of NSObject.
11218  if (!MD->isUnavailable() && !superIsNSObject(MD)) {
11219  Diag(MD->getLocation(),
11220  diag::warn_objc_designated_init_missing_super_call);
11221  Diag(InitMethod->getLocation(),
11222  diag::note_objc_designated_init_marked_here);
11223  }
11224  getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
11225  }
11226  if (getCurFunction()->ObjCWarnForNoInitDelegation) {
11227  // Don't issue this warning for unavaialable inits.
11228  if (!MD->isUnavailable())
11229  Diag(MD->getLocation(),
11230  diag::warn_objc_secondary_init_missing_init_call);
11231  getCurFunction()->ObjCWarnForNoInitDelegation = false;
11232  }
11233  } else {
11234  return nullptr;
11235  }
11236 
11237  assert(!getCurFunction()->ObjCShouldCallSuper &&
11238  "This should only be set for ObjC methods, which should have been "
11239  "handled in the block above.");
11240 
11241  // Verify and clean out per-function state.
11242  if (Body && (!FD || !FD->isDefaulted())) {
11243  // C++ constructors that have function-try-blocks can't have return
11244  // statements in the handlers of that block. (C++ [except.handle]p14)
11245  // Verify this.
11246  if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
11247  DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
11248 
11249  // Verify that gotos and switch cases don't jump into scopes illegally.
11250  if (getCurFunction()->NeedsScopeChecking() &&
11251  !PP.isCodeCompletionEnabled())
11252  DiagnoseInvalidJumps(Body);
11253 
11254  if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
11255  if (!Destructor->getParent()->isDependentType())
11256  CheckDestructor(Destructor);
11257 
11258  MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
11259  Destructor->getParent());
11260  }
11261 
11262  // If any errors have occurred, clear out any temporaries that may have
11263  // been leftover. This ensures that these temporaries won't be picked up for
11264  // deletion in some later function.
11265  if (getDiagnostics().hasErrorOccurred() ||
11266  getDiagnostics().getSuppressAllDiagnostics()) {
11267  DiscardCleanupsInEvaluationContext();
11268  }
11269  if (!getDiagnostics().hasUncompilableErrorOccurred() &&
11270  !isa<FunctionTemplateDecl>(dcl)) {
11271  // Since the body is valid, issue any analysis-based warnings that are
11272  // enabled.
11273  ActivePolicy = &WP;
11274  }
11275 
11276  if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
11277  (!CheckConstexprFunctionDecl(FD) ||
11278  !CheckConstexprFunctionBody(FD, Body)))
11279  FD->setInvalidDecl();
11280 
11281  if (FD && FD->hasAttr<NakedAttr>()) {
11282  for (const Stmt *S : Body->children()) {
11283  if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
11284  Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function);
11285  Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
11286  FD->setInvalidDecl();
11287  break;
11288  }
11289  }
11290  }
11291 
11292  assert(ExprCleanupObjects.size() ==
11293  ExprEvalContexts.back().NumCleanupObjects &&
11294  "Leftover temporaries in function");
11295  assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
11296  assert(MaybeODRUseExprs.empty() &&
11297  "Leftover expressions for odr-use checking");
11298  }
11299 
11300  if (!IsInstantiation)
11301  PopDeclContext();
11302 
11303  PopFunctionScopeInfo(ActivePolicy, dcl);
11304  // If any errors have occurred, clear out any temporaries that may have
11305  // been leftover. This ensures that these temporaries won't be picked up for
11306  // deletion in some later function.
11307  if (getDiagnostics().hasErrorOccurred()) {
11308  DiscardCleanupsInEvaluationContext();
11309  }
11310 
11311  return dcl;
11312 }
11313 
11314 
11315 /// When we finish delayed parsing of an attribute, we must attach it to the
11316 /// relevant Decl.
11318  ParsedAttributes &Attrs) {
11319  // Always attach attributes to the underlying decl.
11320  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
11321  D = TD->getTemplatedDecl();
11322  ProcessDeclAttributeList(S, D, Attrs.getList());
11323 
11324  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
11325  if (Method->isStatic())
11326  checkThisInStaticMemberFunctionAttributes(Method);
11327 }
11328 
11329 
11330 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
11331 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
11333  IdentifierInfo &II, Scope *S) {
11334  // Before we produce a declaration for an implicitly defined
11335  // function, see whether there was a locally-scoped declaration of
11336  // this name as a function or variable. If so, use that
11337  // (non-visible) declaration, and complain about it.
11338  if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
11339  Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev;
11340  Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
11341  return ExternCPrev;
11342  }
11343 
11344  // Extension in C99. Legal in C90, but warn about it.
11345  unsigned diag_id;
11346  if (II.getName().startswith("__builtin_"))
11347  diag_id = diag::warn_builtin_unknown;
11348  else if (getLangOpts().C99)
11349  diag_id = diag::ext_implicit_function_decl;
11350  else
11351  diag_id = diag::warn_implicit_function_decl;
11352  Diag(Loc, diag_id) << &II;
11353 
11354  // Because typo correction is expensive, only do it if the implicit
11355  // function declaration is going to be treated as an error.
11356  if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
11357  TypoCorrection Corrected;
11358  if (S &&
11359  (Corrected = CorrectTypo(
11360  DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr,
11361  llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError)))
11362  diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
11363  /*ErrorRecovery*/false);
11364  }
11365 
11366  // Set a Declarator for the implicit definition: int foo();
11367  const char *Dummy;
11368  AttributeFactory attrFactory;
11369  DeclSpec DS(attrFactory);
11370  unsigned DiagID;
11371  bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
11373  (void)Error; // Silence warning.
11374  assert(!Error && "Error setting up implicit decl!");
11375  SourceLocation NoLoc;
11377  D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
11378  /*IsAmbiguous=*/false,
11379  /*LParenLoc=*/NoLoc,
11380  /*Params=*/nullptr,
11381  /*NumParams=*/0,
11382  /*EllipsisLoc=*/NoLoc,
11383  /*RParenLoc=*/NoLoc,
11384  /*TypeQuals=*/0,
11385  /*RefQualifierIsLvalueRef=*/true,
11386  /*RefQualifierLoc=*/NoLoc,
11387  /*ConstQualifierLoc=*/NoLoc,
11388  /*VolatileQualifierLoc=*/NoLoc,
11389  /*RestrictQualifierLoc=*/NoLoc,
11390  /*MutableLoc=*/NoLoc,
11391  EST_None,
11392  /*ESpecRange=*/SourceRange(),
11393  /*Exceptions=*/nullptr,
11394  /*ExceptionRanges=*/nullptr,
11395  /*NumExceptions=*/0,
11396  /*NoexceptExpr=*/nullptr,
11397  /*ExceptionSpecTokens=*/nullptr,
11398  Loc, Loc, D),
11399  DS.getAttributes(),
11400  SourceLocation());
11401  D.SetIdentifier(&II, Loc);
11402 
11403  // Insert this function into translation-unit scope.
11404 
11405  DeclContext *PrevDC = CurContext;
11406  CurContext = Context.getTranslationUnitDecl();
11407 
11408  FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
11409  FD->setImplicit();
11410 
11411  CurContext = PrevDC;
11412 
11413  AddKnownFunctionAttributes(FD);
11414 
11415  return FD;
11416 }
11417 
11418 /// \brief Adds any function attributes that we know a priori based on
11419 /// the declaration of this function.
11420 ///
11421 /// These attributes can apply both to implicitly-declared builtins
11422 /// (like __builtin___printf_chk) or to library-declared functions
11423 /// like NSLog or printf.
11424 ///
11425 /// We need to check for duplicate attributes both here and where user-written
11426 /// attributes are applied to declarations.
11428  if (FD->isInvalidDecl())
11429  return;
11430 
11431  // If this is a built-in function, map its builtin attributes to
11432  // actual attributes.
11433  if (unsigned BuiltinID = FD->getBuiltinID()) {
11434  // Handle printf-formatting attributes.
11435  unsigned FormatIdx;
11436  bool HasVAListArg;
11437  if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
11438  if (!FD->hasAttr<FormatAttr>()) {
11439  const char *fmt = "printf";
11440  unsigned int NumParams = FD->getNumParams();
11441  if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
11442  FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
11443  fmt = "NSString";
11444  FD->addAttr(FormatAttr::CreateImplicit(Context,
11445  &Context.Idents.get(fmt),
11446  FormatIdx+1,
11447  HasVAListArg ? 0 : FormatIdx+2,
11448  FD->getLocation()));
11449  }
11450  }
11451  if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
11452  HasVAListArg)) {
11453  if (!FD->hasAttr<FormatAttr>())
11454  FD->addAttr(FormatAttr::CreateImplicit(Context,
11455  &Context.Idents.get("scanf"),
11456  FormatIdx+1,
11457  HasVAListArg ? 0 : FormatIdx+2,
11458  FD->getLocation()));
11459  }
11460 
11461  // Mark const if we don't care about errno and that is the only
11462  // thing preventing the function from being const. This allows
11463  // IRgen to use LLVM intrinsics for such functions.
11464  if (!getLangOpts().MathErrno &&
11466  if (!FD->hasAttr<ConstAttr>())
11467  FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
11468  }
11469 
11470  if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
11471  !FD->hasAttr<ReturnsTwiceAttr>())
11472  FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
11473  FD->getLocation()));
11474  if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
11475  FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
11476  if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
11477  FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
11478  if (getLangOpts().CUDA && getLangOpts().CUDATargetOverloads &&
11479  Context.BuiltinInfo.isTSBuiltin(BuiltinID) &&
11480  !FD->hasAttr<CUDADeviceAttr>() && !FD->hasAttr<CUDAHostAttr>()) {
11481  // Assign appropriate attribute depending on CUDA compilation
11482  // mode and the target builtin belongs to. E.g. during host
11483  // compilation, aux builtins are __device__, the rest are __host__.
11484  if (getLangOpts().CUDAIsDevice !=
11485  Context.BuiltinInfo.isAuxBuiltinID(BuiltinID))
11486  FD->addAttr(CUDADeviceAttr::CreateImplicit(Context, FD->getLocation()));
11487  else
11488  FD->addAttr(CUDAHostAttr::CreateImplicit(Context, FD->getLocation()));
11489  }
11490  }
11491 
11492  IdentifierInfo *Name = FD->getIdentifier();
11493  if (!Name)
11494  return;
11495  if ((!getLangOpts().CPlusPlus &&
11496  FD->getDeclContext()->isTranslationUnit()) ||
11497  (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
11498  cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
11500  // Okay: this could be a libc/libm/Objective-C function we know
11501  // about.
11502  } else
11503  return;
11504 
11505  if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
11506  // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
11507  // target-specific builtins, perhaps?
11508  if (!FD->hasAttr<FormatAttr>())
11509  FD->addAttr(FormatAttr::CreateImplicit(Context,
11510  &Context.Idents.get("printf"), 2,
11511  Name->isStr("vasprintf") ? 0 : 3,
11512  FD->getLocation()));
11513  }
11514 
11515  if (Name->isStr("__CFStringMakeConstantString")) {
11516  // We already have a __builtin___CFStringMakeConstantString,
11517  // but builds that use -fno-constant-cfstrings don't go through that.
11518  if (!FD->hasAttr<FormatArgAttr>())
11519  FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1,
11520  FD->getLocation()));
11521  }
11522 }
11523 
11525  TypeSourceInfo *TInfo) {
11526  assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
11527  assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
11528 
11529  if (!TInfo) {
11530  assert(D.isInvalidType() && "no declarator info for valid type");
11531  TInfo = Context.getTrivialTypeSourceInfo(T);
11532  }
11533 
11534  // Scope manipulation handled by caller.
11535  TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
11536  D.getLocStart(),
11537  D.getIdentifierLoc(),
11538  D.getIdentifier(),
11539  TInfo);
11540 
11541  // Bail out immediately if we have an invalid declaration.
11542  if (D.isInvalidType()) {
11543  NewTD->setInvalidDecl();
11544  return NewTD;
11545  }
11546 
11548  if (CurContext->isFunctionOrMethod())
11549  Diag(NewTD->getLocation(), diag::err_module_private_local)
11550  << 2 << NewTD->getDeclName()
11553  else
11554  NewTD->setModulePrivate();
11555  }
11556 
11557  // C++ [dcl.typedef]p8:
11558  // If the typedef declaration defines an unnamed class (or
11559  // enum), the first typedef-name declared by the declaration
11560  // to be that class type (or enum type) is used to denote the
11561  // class type (or enum type) for linkage purposes only.
11562  // We need to check whether the type was declared in the declaration.
11563  switch (D.getDeclSpec().getTypeSpecType()) {
11564  case TST_enum:
11565  case TST_struct:
11566  case TST_interface:
11567  case TST_union:
11568  case TST_class: {
11569  TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
11570  setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD);
11571  break;
11572  }
11573 
11574  default:
11575  break;
11576  }
11577 
11578  return NewTD;
11579 }
11580 
11581 
11582 /// \brief Check that this is a valid underlying type for an enum declaration.
11584  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
11585  QualType T = TI->getType();
11586 
11587  if (T->isDependentType())
11588  return false;
11589 
11590  if (const BuiltinType *BT = T->getAs<BuiltinType>())
11591  if (BT->isInteger())
11592  return false;
11593 
11594  Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
11595  return true;
11596 }
11597 
11598 /// Check whether this is a valid redeclaration of a previous enumeration.
11599 /// \return true if the redeclaration was invalid.
11601  SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy,
11602  bool EnumUnderlyingIsImplicit, const EnumDecl *Prev) {
11603  bool IsFixed = !EnumUnderlyingTy.isNull();
11604 
11605  if (IsScoped != Prev->isScoped()) {
11606  Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
11607  << Prev->isScoped();
11608  Diag(Prev->getLocation(), diag::note_previous_declaration);
11609  return true;
11610  }
11611 
11612  if (IsFixed && Prev->isFixed()) {
11613  if (!EnumUnderlyingTy->isDependentType() &&
11614  !Prev->getIntegerType()->isDependentType() &&
11615  !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
11616  Prev->getIntegerType())) {
11617  // TODO: Highlight the underlying type of the redeclaration.
11618  Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
11619  << EnumUnderlyingTy << Prev->getIntegerType();
11620  Diag(Prev->getLocation(), diag::note_previous_declaration)
11621  << Prev->getIntegerTypeRange();
11622  return true;
11623  }
11624  } else if (IsFixed && !Prev->isFixed() && EnumUnderlyingIsImplicit) {
11625  ;
11626  } else if (!IsFixed && Prev->isFixed() && !Prev->getIntegerTypeSourceInfo()) {
11627  ;
11628  } else if (IsFixed != Prev->isFixed()) {
11629  Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
11630  << Prev->isFixed();
11631  Diag(Prev->getLocation(), diag::note_previous_declaration);
11632  return true;
11633  }
11634 
11635  return false;
11636 }
11637 
11638 /// \brief Get diagnostic %select index for tag kind for
11639 /// redeclaration diagnostic message.
11640 /// WARNING: Indexes apply to particular diagnostics only!
11641 ///
11642 /// \returns diagnostic %select index.
11644  switch (Tag) {
11645  case TTK_Struct: return 0;
11646  case TTK_Interface: return 1;
11647  case TTK_Class: return 2;
11648  default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
11649  }
11650 }
11651 
11652 /// \brief Determine if tag kind is a class-key compatible with
11653 /// class for redeclaration (class, struct, or __interface).
11654 ///
11655 /// \returns true iff the tag kind is compatible.
11657 {
11658  return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
11659 }
11660 
11661 /// \brief Determine whether a tag with a given kind is acceptable
11662 /// as a redeclaration of the given tag declaration.
11663 ///
11664 /// \returns true if the new tag kind is acceptable, false otherwise.
11666  TagTypeKind NewTag, bool isDefinition,
11667  SourceLocation NewTagLoc,
11668  const IdentifierInfo *Name) {
11669  // C++ [dcl.type.elab]p3:
11670  // The class-key or enum keyword present in the
11671  // elaborated-type-specifier shall agree in kind with the
11672  // declaration to which the name in the elaborated-type-specifier
11673  // refers. This rule also applies to the form of
11674  // elaborated-type-specifier that declares a class-name or
11675  // friend class since it can be construed as referring to the
11676  // definition of the class. Thus, in any
11677  // elaborated-type-specifier, the enum keyword shall be used to
11678  // refer to an enumeration (7.2), the union class-key shall be
11679  // used to refer to a union (clause 9), and either the class or
11680  // struct class-key shall be used to refer to a class (clause 9)
11681  // declared using the class or struct class-key.
11682  TagTypeKind OldTag = Previous->getTagKind();
11683  if (!isDefinition || !isClassCompatTagKind(NewTag))
11684  if (OldTag == NewTag)
11685  return true;
11686 
11687  if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
11688  // Warn about the struct/class tag mismatch.
11689  bool isTemplate = false;
11690  if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
11691  isTemplate = Record->getDescribedClassTemplate();
11692 
11693  if (!ActiveTemplateInstantiations.empty()) {
11694  // In a template instantiation, do not offer fix-its for tag mismatches
11695  // since they usually mess up the template instead of fixing the problem.
11696  Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
11697  << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
11698  << getRedeclDiagFromTagKind(OldTag);
11699  return true;
11700  }
11701 
11702  if (isDefinition) {
11703  // On definitions, check previous tags and issue a fix-it for each
11704  // one that doesn't match the current tag.
11705  if (Previous->getDefinition()) {
11706  // Don't suggest fix-its for redefinitions.
11707  return true;
11708  }
11709 
11710  bool previousMismatch = false;
11711  for (auto I : Previous->redecls()) {
11712  if (I->getTagKind() != NewTag) {
11713  if (!previousMismatch) {
11714  previousMismatch = true;
11715  Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
11716  << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
11717  << getRedeclDiagFromTagKind(I->getTagKind());
11718  }
11719  Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
11720  << getRedeclDiagFromTagKind(NewTag)
11721  << FixItHint::CreateReplacement(I->getInnerLocStart(),
11723  }
11724  }
11725  return true;
11726  }
11727 
11728  // Check for a previous definition. If current tag and definition
11729  // are same type, do nothing. If no definition, but disagree with
11730  // with previous tag type, give a warning, but no fix-it.
11731  const TagDecl *Redecl = Previous->getDefinition() ?
11732  Previous->getDefinition() : Previous;
11733  if (Redecl->getTagKind() == NewTag) {
11734  return true;
11735  }
11736 
11737  Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
11738  << getRedeclDiagFromTagKind(NewTag) << isTemplate << Name
11739  << getRedeclDiagFromTagKind(OldTag);
11740  Diag(Redecl->getLocation(), diag::note_previous_use);
11741 
11742  // If there is a previous definition, suggest a fix-it.
11743  if (Previous->getDefinition()) {
11744  Diag(NewTagLoc, diag::note_struct_class_suggestion)
11745  << getRedeclDiagFromTagKind(Redecl->getTagKind())
11748  }
11749 
11750  return true;
11751  }
11752  return false;
11753 }
11754 
11755 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
11756 /// from an outer enclosing namespace or file scope inside a friend declaration.
11757 /// This should provide the commented out code in the following snippet:
11758 /// namespace N {
11759 /// struct X;
11760 /// namespace M {
11761 /// struct Y { friend struct /*N::*/ X; };
11762 /// }
11763 /// }
11765  SourceLocation NameLoc) {
11766  // While the decl is in a namespace, do repeated lookup of that name and see
11767  // if we get the same namespace back. If we do not, continue until
11768  // translation unit scope, at which point we have a fully qualified NNS.
11771  for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
11772  // This tag should be declared in a namespace, which can only be enclosed by
11773  // other namespaces. Bail if there's an anonymous namespace in the chain.
11774  NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
11775  if (!Namespace || Namespace->isAnonymousNamespace())
11776  return FixItHint();
11777  IdentifierInfo *II = Namespace->getIdentifier();
11778  Namespaces.push_back(II);
11779  NamedDecl *Lookup = SemaRef.LookupSingleName(
11780  S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
11781  if (Lookup == Namespace)
11782  break;
11783  }
11784 
11785  // Once we have all the namespaces, reverse them to go outermost first, and
11786  // build an NNS.
11787  SmallString<64> Insertion;
11788  llvm::raw_svector_ostream OS(Insertion);
11789  if (DC->isTranslationUnit())
11790  OS << "::";
11791  std::reverse(Namespaces.begin(), Namespaces.end());
11792  for (auto *II : Namespaces)
11793  OS << II->getName() << "::";
11794  return FixItHint::CreateInsertion(NameLoc, Insertion);
11795 }
11796 
11797 /// \brief Determine whether a tag originally declared in context \p OldDC can
11798 /// be redeclared with an unqualfied name in \p NewDC (assuming name lookup
11799 /// found a declaration in \p OldDC as a previous decl, perhaps through a
11800 /// using-declaration).
11802  DeclContext *NewDC) {
11803  OldDC = OldDC->getRedeclContext();
11804  NewDC = NewDC->getRedeclContext();
11805 
11806  if (OldDC->Equals(NewDC))
11807  return true;
11808 
11809  // In MSVC mode, we allow a redeclaration if the contexts are related (either
11810  // encloses the other).
11811  if (S.getLangOpts().MSVCCompat &&
11812  (OldDC->Encloses(NewDC) || NewDC->Encloses(OldDC)))
11813  return true;
11814 
11815  return false;
11816 }
11817 
11818 /// Find the DeclContext in which a tag is implicitly declared if we see an
11819 /// elaborated type specifier in the specified context, and lookup finds
11820 /// nothing.
11822  while (!DC->isFileContext() && !DC->isFunctionOrMethod())
11823  DC = DC->getParent();
11824  return DC;
11825 }
11826 
11827 /// Find the Scope in which a tag is implicitly declared if we see an
11828 /// elaborated type specifier in the specified context, and lookup finds
11829 /// nothing.
11830 static Scope *getTagInjectionScope(Scope *S, const LangOptions &LangOpts) {
11831  while (S->isClassScope() ||
11832  (LangOpts.CPlusPlus &&
11833  S->isFunctionPrototypeScope()) ||
11834  ((S->getFlags() & Scope::DeclScope) == 0) ||
11835  (S->getEntity() && S->getEntity()->isTransparentContext()))
11836  S = S->getParent();
11837  return S;
11838 }
11839 
11840 /// \brief This is invoked when we see 'struct foo' or 'struct {'. In the
11841 /// former case, Name will be non-null. In the later case, Name will be null.
11842 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
11843 /// reference/declaration/definition of a tag.
11844 ///
11845 /// \param IsTypeSpecifier \c true if this is a type-specifier (or
11846 /// trailing-type-specifier) other than one in an alias-declaration.
11847 ///
11848 /// \param SkipBody If non-null, will be set to indicate if the caller should
11849 /// skip the definition of this tag and treat it as if it were a declaration.
11850 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
11851  SourceLocation KWLoc, CXXScopeSpec &SS,
11852  IdentifierInfo *Name, SourceLocation NameLoc,
11854  SourceLocation ModulePrivateLoc,
11855  MultiTemplateParamsArg TemplateParameterLists,
11856  bool &OwnedDecl, bool &IsDependent,
11857  SourceLocation ScopedEnumKWLoc,
11858  bool ScopedEnumUsesClassTag,
11859  TypeResult UnderlyingType,
11860  bool IsTypeSpecifier, SkipBodyInfo *SkipBody) {
11861  // If this is not a definition, it must have a name.
11862  IdentifierInfo *OrigName = Name;
11863  assert((Name != nullptr || TUK == TUK_Definition) &&
11864  "Nameless record must be a definition!");
11865  assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
11866 
11867  OwnedDecl = false;
11869  bool ScopedEnum = ScopedEnumKWLoc.isValid();
11870 
11871  // FIXME: Check explicit specializations more carefully.
11872  bool isExplicitSpecialization = false;
11873  bool Invalid = false;
11874 
11875  // We only need to do this matching if we have template parameters
11876  // or a scope specifier, which also conveniently avoids this work
11877  // for non-C++ cases.
11878  if (TemplateParameterLists.size() > 0 ||
11879  (SS.isNotEmpty() && TUK != TUK_Reference)) {
11880  if (TemplateParameterList *TemplateParams =
11881  MatchTemplateParametersToScopeSpecifier(
11882  KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
11883  TUK == TUK_Friend, isExplicitSpecialization, Invalid)) {
11884  if (Kind == TTK_Enum) {
11885  Diag(KWLoc, diag::err_enum_template);
11886  return nullptr;
11887  }
11888 
11889  if (TemplateParams->size() > 0) {
11890  // This is a declaration or definition of a class template (which may
11891  // be a member of another template).
11892 
11893  if (Invalid)
11894  return nullptr;
11895 
11896  OwnedDecl = false;
11897  DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
11898  SS, Name, NameLoc, Attr,
11899  TemplateParams, AS,
11900  ModulePrivateLoc,
11901  /*FriendLoc*/SourceLocation(),
11902  TemplateParameterLists.size()-1,
11903  TemplateParameterLists.data(),
11904  SkipBody);
11905  return Result.get();
11906  } else {
11907  // The "template<>" header is extraneous.
11908  Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
11910  isExplicitSpecialization = true;
11911  }
11912  }
11913  }
11914 
11915  // Figure out the underlying type if this a enum declaration. We need to do
11916  // this early, because it's needed to detect if this is an incompatible
11917  // redeclaration.
11918  llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
11919  bool EnumUnderlyingIsImplicit = false;
11920 
11921  if (Kind == TTK_Enum) {
11922  if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
11923  // No underlying type explicitly specified, or we failed to parse the
11924  // type, default to int.
11925  EnumUnderlying = Context.IntTy.getTypePtr();
11926  else if (UnderlyingType.get()) {
11927  // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
11928  // integral type; any cv-qualification is ignored.
11929  TypeSourceInfo *TI = nullptr;
11930  GetTypeFromParser(UnderlyingType.get(), &TI);
11931  EnumUnderlying = TI;
11932 
11933  if (CheckEnumUnderlyingType(TI))
11934  // Recover by falling back to int.
11935  EnumUnderlying = Context.IntTy.getTypePtr();
11936 
11937  if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
11938  UPPC_FixedUnderlyingType))
11939  EnumUnderlying = Context.IntTy.getTypePtr();
11940 
11941  } else if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
11942  if (getLangOpts().MSVCCompat || TUK == TUK_Definition) {
11943  // Microsoft enums are always of int type.
11944  EnumUnderlying = Context.IntTy.getTypePtr();
11945  EnumUnderlyingIsImplicit = true;
11946  }
11947  }
11948  }
11949 
11950  DeclContext *SearchDC = CurContext;
11951  DeclContext *DC = CurContext;
11952  bool isStdBadAlloc = false;
11953 
11954  RedeclarationKind Redecl = ForRedeclaration;
11955  if (TUK == TUK_Friend || TUK == TUK_Reference)
11956  Redecl = NotForRedeclaration;
11957 
11958  LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
11959  if (Name && SS.isNotEmpty()) {
11960  // We have a nested-name tag ('struct foo::bar').
11961 
11962  // Check for invalid 'foo::'.
11963  if (SS.isInvalid()) {
11964  Name = nullptr;
11965  goto CreateNewDecl;
11966  }
11967 
11968  // If this is a friend or a reference to a class in a dependent
11969  // context, don't try to make a decl for it.
11970  if (TUK == TUK_Friend || TUK == TUK_Reference) {
11971  DC = computeDeclContext(SS, false);
11972  if (!DC) {
11973  IsDependent = true;
11974  return nullptr;
11975  }
11976  } else {
11977  DC = computeDeclContext(SS, true);
11978  if (!DC) {
11979  Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
11980  << SS.getRange();
11981  return nullptr;
11982  }
11983  }
11984 
11985  if (RequireCompleteDeclContext(SS, DC))
11986  return nullptr;
11987 
11988  SearchDC = DC;
11989  // Look-up name inside 'foo::'.
11990  LookupQualifiedName(Previous, DC);
11991 
11992  if (Previous.isAmbiguous())
11993  return nullptr;
11994 
11995  if (Previous.empty()) {
11996  // Name lookup did not find anything. However, if the
11997  // nested-name-specifier refers to the current instantiation,
11998  // and that current instantiation has any dependent base
11999  // classes, we might find something at instantiation time: treat
12000  // this as a dependent elaborated-type-specifier.
12001  // But this only makes any sense for reference-like lookups.
12002  if (Previous.wasNotFoundInCurrentInstantiation() &&
12003  (TUK == TUK_Reference || TUK == TUK_Friend)) {
12004  IsDependent = true;
12005  return nullptr;
12006  }
12007 
12008  // A tag 'foo::bar' must already exist.
12009  Diag(NameLoc, diag::err_not_tag_in_scope)
12010  << Kind << Name << DC << SS.getRange();
12011  Name = nullptr;
12012  Invalid = true;
12013  goto CreateNewDecl;
12014  }
12015  } else if (Name) {
12016  // C++14 [class.mem]p14:
12017  // If T is the name of a class, then each of the following shall have a
12018  // name different from T:
12019  // -- every member of class T that is itself a type
12020  if (TUK != TUK_Reference && TUK != TUK_Friend &&
12021  DiagnoseClassNameShadow(SearchDC, DeclarationNameInfo(Name, NameLoc)))
12022  return nullptr;
12023 
12024  // If this is a named struct, check to see if there was a previous forward
12025  // declaration or definition.
12026  // FIXME: We're looking into outer scopes here, even when we
12027  // shouldn't be. Doing so can result in ambiguities that we
12028  // shouldn't be diagnosing.
12029  LookupName(Previous, S);
12030 
12031  // When declaring or defining a tag, ignore ambiguities introduced
12032  // by types using'ed into this scope.
12033  if (Previous.isAmbiguous() &&
12034  (TUK == TUK_Definition || TUK == TUK_Declaration)) {
12035  LookupResult::Filter F = Previous.makeFilter();
12036  while (F.hasNext()) {
12037  NamedDecl *ND = F.next();
12038  if (ND->getDeclContext()->getRedeclContext() != SearchDC)
12039  F.erase();
12040  }
12041  F.done();
12042  }
12043 
12044  // C++11 [namespace.memdef]p3:
12045  // If the name in a friend declaration is neither qualified nor
12046  // a template-id and the declaration is a function or an
12047  // elaborated-type-specifier, the lookup to determine whether
12048  // the entity has been previously declared shall not consider
12049  // any scopes outside the innermost enclosing namespace.
12050  //
12051  // MSVC doesn't implement the above rule for types, so a friend tag
12052  // declaration may be a redeclaration of a type declared in an enclosing
12053  // scope. They do implement this rule for friend functions.
12054  //
12055  // Does it matter that this should be by scope instead of by
12056  // semantic context?
12057  if (!Previous.empty() && TUK == TUK_Friend) {
12058  DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
12059  LookupResult::Filter F = Previous.makeFilter();
12060  bool FriendSawTagOutsideEnclosingNamespace = false;
12061  while (F.hasNext()) {
12062  NamedDecl *ND = F.next();
12064  if (DC->isFileContext() &&
12065  !EnclosingNS->Encloses(ND->getDeclContext())) {
12066  if (getLangOpts().MSVCCompat)
12067  FriendSawTagOutsideEnclosingNamespace = true;
12068  else
12069  F.erase();
12070  }
12071  }
12072  F.done();
12073 
12074  // Diagnose this MSVC extension in the easy case where lookup would have
12075  // unambiguously found something outside the enclosing namespace.
12076  if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
12077  NamedDecl *ND = Previous.getFoundDecl();
12078  Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
12079  << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
12080  }
12081  }
12082 
12083  // Note: there used to be some attempt at recovery here.
12084  if (Previous.isAmbiguous())
12085  return nullptr;
12086 
12087  if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
12088  // FIXME: This makes sure that we ignore the contexts associated
12089  // with C structs, unions, and enums when looking for a matching
12090  // tag declaration or definition. See the similar lookup tweak
12091  // in Sema::LookupName; is there a better way to deal with this?
12092  while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
12093  SearchDC = SearchDC->getParent();
12094  }
12095  }
12096 
12097  if (Previous.isSingleResult() &&
12098  Previous.getFoundDecl()->isTemplateParameter()) {
12099  // Maybe we will complain about the shadowed template parameter.
12100  DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
12101  // Just pretend that we didn't see the previous declaration.
12102  Previous.clear();
12103  }
12104 
12105  if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
12106  DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
12107  // This is a declaration of or a reference to "std::bad_alloc".
12108  isStdBadAlloc = true;
12109 
12110  if (Previous.empty() && StdBadAlloc) {
12111  // std::bad_alloc has been implicitly declared (but made invisible to
12112  // name lookup). Fill in this implicit declaration as the previous
12113  // declaration, so that the declarations get chained appropriately.
12114  Previous.addDecl(getStdBadAlloc());
12115  }
12116  }
12117 
12118  // If we didn't find a previous declaration, and this is a reference
12119  // (or friend reference), move to the correct scope. In C++, we
12120  // also need to do a redeclaration lookup there, just in case
12121  // there's a shadow friend decl.
12122  if (Name && Previous.empty() &&
12123  (TUK == TUK_Reference || TUK == TUK_Friend)) {
12124  if (Invalid) goto CreateNewDecl;
12125  assert(SS.isEmpty());
12126 
12127  if (TUK == TUK_Reference) {
12128  // C++ [basic.scope.pdecl]p5:
12129  // -- for an elaborated-type-specifier of the form
12130  //
12131  // class-key identifier
12132  //
12133  // if the elaborated-type-specifier is used in the
12134  // decl-specifier-seq or parameter-declaration-clause of a
12135  // function defined in namespace scope, the identifier is
12136  // declared as a class-name in the namespace that contains
12137  // the declaration; otherwise, except as a friend
12138  // declaration, the identifier is declared in the smallest
12139  // non-class, non-function-prototype scope that contains the
12140  // declaration.
12141  //
12142  // C99 6.7.2.3p8 has a similar (but not identical!) provision for
12143  // C structs and unions.
12144  //
12145  // It is an error in C++ to declare (rather than define) an enum
12146  // type, including via an elaborated type specifier. We'll
12147  // diagnose that later; for now, declare the enum in the same
12148  // scope as we would have picked for any other tag type.
12149  //
12150  // GNU C also supports this behavior as part of its incomplete
12151  // enum types extension, while GNU C++ does not.
12152  //
12153  // Find the context where we'll be declaring the tag.
12154  // FIXME: We would like to maintain the current DeclContext as the
12155  // lexical context,
12156  SearchDC = getTagInjectionContext(SearchDC);
12157 
12158  // Find the scope where we'll be declaring the tag.
12159  S = getTagInjectionScope(S, getLangOpts());
12160  } else {
12161  assert(TUK == TUK_Friend);
12162  // C++ [namespace.memdef]p3:
12163  // If a friend declaration in a non-local class first declares a
12164  // class or function, the friend class or function is a member of
12165  // the innermost enclosing namespace.
12166  SearchDC = SearchDC->getEnclosingNamespaceContext();
12167  }
12168 
12169  // In C++, we need to do a redeclaration lookup to properly
12170  // diagnose some problems.
12171  // FIXME: redeclaration lookup is also used (with and without C++) to find a
12172  // hidden declaration so that we don't get ambiguity errors when using a
12173  // type declared by an elaborated-type-specifier. In C that is not correct
12174  // and we should instead merge compatible types found by lookup.
12175  if (getLangOpts().CPlusPlus) {
12176  Previous.setRedeclarationKind(ForRedeclaration);
12177  LookupQualifiedName(Previous, SearchDC);
12178  } else {
12179  Previous.setRedeclarationKind(ForRedeclaration);
12180  LookupName(Previous, S);
12181  }
12182  }
12183 
12184  // If we have a known previous declaration to use, then use it.
12185  if (Previous.empty() && SkipBody && SkipBody->Previous)
12186  Previous.addDecl(SkipBody->Previous);
12187 
12188  if (!Previous.empty()) {
12189  NamedDecl *PrevDecl = Previous.getFoundDecl();
12190  NamedDecl *DirectPrevDecl = Previous.getRepresentativeDecl();
12191 
12192  // It's okay to have a tag decl in the same scope as a typedef
12193  // which hides a tag decl in the same scope. Finding this
12194  // insanity with a redeclaration lookup can only actually happen
12195  // in C++.
12196  //
12197  // This is also okay for elaborated-type-specifiers, which is
12198  // technically forbidden by the current standard but which is
12199  // okay according to the likely resolution of an open issue;
12200  // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
12201  if (getLangOpts().CPlusPlus) {
12202  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
12203  if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
12204  TagDecl *Tag = TT->getDecl();
12205  if (Tag->getDeclName() == Name &&
12207  ->Equals(TD->getDeclContext()->getRedeclContext())) {
12208  PrevDecl = Tag;
12209  Previous.clear();
12210  Previous.addDecl(Tag);
12211  Previous.resolveKind();
12212  }
12213  }
12214  }
12215  }
12216 
12217  // If this is a redeclaration of a using shadow declaration, it must
12218  // declare a tag in the same context. In MSVC mode, we allow a
12219  // redefinition if either context is within the other.
12220  if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
12221  auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
12222  if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend &&
12223  isDeclInScope(Shadow, SearchDC, S, isExplicitSpecialization) &&
12224  !(OldTag && isAcceptableTagRedeclContext(
12225  *this, OldTag->getDeclContext(), SearchDC))) {
12226  Diag(KWLoc, diag::err_using_decl_conflict_reverse);
12227  Diag(Shadow->getTargetDecl()->getLocation(),
12228  diag::note_using_decl_target);
12229  Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl)
12230  << 0;
12231  // Recover by ignoring the old declaration.
12232  Previous.clear();
12233  goto CreateNewDecl;
12234  }
12235  }
12236 
12237  if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
12238  // If this is a use of a previous tag, or if the tag is already declared
12239  // in the same scope (so that the definition/declaration completes or
12240  // rementions the tag), reuse the decl.
12241  if (TUK == TUK_Reference || TUK == TUK_Friend ||
12242  isDeclInScope(DirectPrevDecl, SearchDC, S,
12243  SS.isNotEmpty() || isExplicitSpecialization)) {
12244  // Make sure that this wasn't declared as an enum and now used as a
12245  // struct or something similar.
12246  if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
12247  TUK == TUK_Definition, KWLoc,
12248  Name)) {
12249  bool SafeToContinue
12250  = (PrevTagDecl->getTagKind() != TTK_Enum &&
12251  Kind != TTK_Enum);
12252  if (SafeToContinue)
12253  Diag(KWLoc, diag::err_use_with_wrong_tag)
12254  << Name
12256  PrevTagDecl->getKindName());
12257  else
12258  Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
12259  Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
12260 
12261  if (SafeToContinue)
12262  Kind = PrevTagDecl->getTagKind();
12263  else {
12264  // Recover by making this an anonymous redefinition.
12265  Name = nullptr;
12266  Previous.clear();
12267  Invalid = true;
12268  }
12269  }
12270 
12271  if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
12272  const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
12273 
12274  // If this is an elaborated-type-specifier for a scoped enumeration,
12275  // the 'class' keyword is not necessary and not permitted.
12276  if (TUK == TUK_Reference || TUK == TUK_Friend) {
12277  if (ScopedEnum)
12278  Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
12279  << PrevEnum->isScoped()
12280  << FixItHint::CreateRemoval(ScopedEnumKWLoc);
12281  return PrevTagDecl;
12282  }
12283 
12284  QualType EnumUnderlyingTy;
12285  if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
12286  EnumUnderlyingTy = TI->getType().getUnqualifiedType();
12287  else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
12288  EnumUnderlyingTy = QualType(T, 0);
12289 
12290  // All conflicts with previous declarations are recovered by
12291  // returning the previous declaration, unless this is a definition,
12292  // in which case we want the caller to bail out.
12293  if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
12294  ScopedEnum, EnumUnderlyingTy,
12295  EnumUnderlyingIsImplicit, PrevEnum))
12296  return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
12297  }
12298 
12299  // C++11 [class.mem]p1:
12300  // A member shall not be declared twice in the member-specification,
12301  // except that a nested class or member class template can be declared
12302  // and then later defined.
12303  if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
12304  S->isDeclScope(PrevDecl)) {
12305  Diag(NameLoc, diag::ext_member_redeclared);
12306  Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
12307  }
12308 
12309  if (!Invalid) {
12310  // If this is a use, just return the declaration we found, unless
12311  // we have attributes.
12312  if (TUK == TUK_Reference || TUK == TUK_Friend) {
12313  if (Attr) {
12314  // FIXME: Diagnose these attributes. For now, we create a new
12315  // declaration to hold them.
12316  } else if (TUK == TUK_Reference &&
12317  (PrevTagDecl->getFriendObjectKind() ==
12319  PP.getModuleContainingLocation(
12320  PrevDecl->getLocation()) !=
12321  PP.getModuleContainingLocation(KWLoc)) &&
12322  SS.isEmpty()) {
12323  // This declaration is a reference to an existing entity, but
12324  // has different visibility from that entity: it either makes
12325  // a friend visible or it makes a type visible in a new module.
12326  // In either case, create a new declaration. We only do this if
12327  // the declaration would have meant the same thing if no prior
12328  // declaration were found, that is, if it was found in the same
12329  // scope where we would have injected a declaration.
12330  if (!getTagInjectionContext(CurContext)->getRedeclContext()
12331  ->Equals(PrevDecl->getDeclContext()->getRedeclContext()))
12332  return PrevTagDecl;
12333  // This is in the injected scope, create a new declaration in
12334  // that scope.
12335  S = getTagInjectionScope(S, getLangOpts());
12336  } else {
12337  return PrevTagDecl;
12338  }
12339  }
12340 
12341  // Diagnose attempts to redefine a tag.
12342  if (TUK == TUK_Definition) {
12343  if (NamedDecl *Def = PrevTagDecl->getDefinition()) {
12344  // If we're defining a specialization and the previous definition
12345  // is from an implicit instantiation, don't emit an error
12346  // here; we'll catch this in the general case below.
12347  bool IsExplicitSpecializationAfterInstantiation = false;
12348  if (isExplicitSpecialization) {
12349  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
12350  IsExplicitSpecializationAfterInstantiation =
12351  RD->getTemplateSpecializationKind() !=
12353  else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
12354  IsExplicitSpecializationAfterInstantiation =
12355  ED->getTemplateSpecializationKind() !=
12357  }
12358 
12359  NamedDecl *Hidden = nullptr;
12360  if (SkipBody && getLangOpts().CPlusPlus &&
12361  !hasVisibleDefinition(Def, &Hidden)) {
12362  // There is a definition of this tag, but it is not visible. We
12363  // explicitly make use of C++'s one definition rule here, and
12364  // assume that this definition is identical to the hidden one
12365  // we already have. Make the existing definition visible and
12366  // use it in place of this one.
12367  SkipBody->ShouldSkip = true;
12368  makeMergedDefinitionVisible(Hidden, KWLoc);
12369  return Def;
12370  } else if (!IsExplicitSpecializationAfterInstantiation) {
12371  // A redeclaration in function prototype scope in C isn't
12372  // visible elsewhere, so merely issue a warning.
12373  if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
12374  Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
12375  else
12376  Diag(NameLoc, diag::err_redefinition) << Name;
12377  Diag(Def->getLocation(), diag::note_previous_definition);
12378  // If this is a redefinition, recover by making this
12379  // struct be anonymous, which will make any later
12380  // references get the previous definition.
12381  Name = nullptr;
12382  Previous.clear();
12383  Invalid = true;
12384  }
12385  } else {
12386  // If the type is currently being defined, complain
12387  // about a nested redefinition.
12388  auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl();
12389  if (TD->isBeingDefined()) {
12390  Diag(NameLoc, diag::err_nested_redefinition) << Name;
12391  Diag(PrevTagDecl->getLocation(),
12392  diag::note_previous_definition);
12393  Name = nullptr;
12394  Previous.clear();
12395  Invalid = true;
12396  }
12397  }
12398 
12399  // Okay, this is definition of a previously declared or referenced
12400  // tag. We're going to create a new Decl for it.
12401  }
12402 
12403  // Okay, we're going to make a redeclaration. If this is some kind
12404  // of reference, make sure we build the redeclaration in the same DC
12405  // as the original, and ignore the current access specifier.
12406  if (TUK == TUK_Friend || TUK == TUK_Reference) {
12407  SearchDC = PrevTagDecl->getDeclContext();
12408  AS = AS_none;
12409  }
12410  }
12411  // If we get here we have (another) forward declaration or we
12412  // have a definition. Just create a new decl.
12413 
12414  } else {
12415  // If we get here, this is a definition of a new tag type in a nested
12416  // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
12417  // new decl/type. We set PrevDecl to NULL so that the entities
12418  // have distinct types.
12419  Previous.clear();
12420  }
12421  // If we get here, we're going to create a new Decl. If PrevDecl
12422  // is non-NULL, it's a definition of the tag declared by
12423  // PrevDecl. If it's NULL, we have a new definition.
12424 
12425 
12426  // Otherwise, PrevDecl is not a tag, but was found with tag
12427  // lookup. This is only actually possible in C++, where a few
12428  // things like templates still live in the tag namespace.
12429  } else {
12430  // Use a better diagnostic if an elaborated-type-specifier
12431  // found the wrong kind of type on the first
12432  // (non-redeclaration) lookup.
12433  if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
12434  !Previous.isForRedeclaration()) {
12435  unsigned Kind = 0;
12436  if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
12437  else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
12438  else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
12439  Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
12440  Diag(PrevDecl->getLocation(), diag::note_declared_at);
12441  Invalid = true;
12442 
12443  // Otherwise, only diagnose if the declaration is in scope.
12444  } else if (!isDeclInScope(DirectPrevDecl, SearchDC, S,
12445  SS.isNotEmpty() || isExplicitSpecialization)) {
12446  // do nothing
12447 
12448  // Diagnose implicit declarations introduced by elaborated types.
12449  } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
12450  unsigned Kind = 0;
12451  if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
12452  else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
12453  else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
12454  Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
12455  Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
12456  Invalid = true;
12457 
12458  // Otherwise it's a declaration. Call out a particularly common
12459  // case here.
12460  } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
12461  unsigned Kind = 0;
12462  if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
12463  Diag(NameLoc, diag::err_tag_definition_of_typedef)
12464  << Name << Kind << TND->getUnderlyingType();
12465  Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
12466  Invalid = true;
12467 
12468  // Otherwise, diagnose.
12469  } else {
12470  // The tag name clashes with something else in the target scope,
12471  // issue an error and recover by making this tag be anonymous.
12472  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
12473  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
12474  Name = nullptr;
12475  Invalid = true;
12476  }
12477 
12478  // The existing declaration isn't relevant to us; we're in a
12479  // new scope, so clear out the previous declaration.
12480  Previous.clear();
12481  }
12482  }
12483 
12484 CreateNewDecl:
12485 
12486  TagDecl *PrevDecl = nullptr;
12487  if (Previous.isSingleResult())
12488  PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
12489 
12490  // If there is an identifier, use the location of the identifier as the
12491  // location of the decl, otherwise use the location of the struct/union
12492  // keyword.
12493  SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
12494 
12495  // Otherwise, create a new declaration. If there is a previous
12496  // declaration of the same entity, the two will be linked via
12497  // PrevDecl.
12498  TagDecl *New;
12499 
12500  bool IsForwardReference = false;
12501  if (Kind == TTK_Enum) {
12502  // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12503  // enum X { A, B, C } D; D should chain to X.
12504  New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
12505  cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
12506  ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
12507  // If this is an undefined enum, warn.
12508  if (TUK != TUK_Definition && !Invalid) {
12509  TagDecl *Def;
12510  if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
12511  cast<EnumDecl>(New)->isFixed()) {
12512  // C++0x: 7.2p2: opaque-enum-declaration.
12513  // Conflicts are diagnosed above. Do nothing.
12514  }
12515  else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
12516  Diag(Loc, diag::ext_forward_ref_enum_def)
12517  << New;
12518  Diag(Def->getLocation(), diag::note_previous_definition);
12519  } else {
12520  unsigned DiagID = diag::ext_forward_ref_enum;
12521  if (getLangOpts().MSVCCompat)
12522  DiagID = diag::ext_ms_forward_ref_enum;
12523  else if (getLangOpts().CPlusPlus)
12524  DiagID = diag::err_forward_ref_enum;
12525  Diag(Loc, DiagID);
12526 
12527  // If this is a forward-declared reference to an enumeration, make a
12528  // note of it; we won't actually be introducing the declaration into
12529  // the declaration context.
12530  if (TUK == TUK_Reference)
12531  IsForwardReference = true;
12532  }
12533  }
12534 
12535  if (EnumUnderlying) {
12536  EnumDecl *ED = cast<EnumDecl>(New);
12537  if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
12538  ED->setIntegerTypeSourceInfo(TI);
12539  else
12540  ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
12541  ED->setPromotionType(ED->getIntegerType());
12542  }
12543 
12544  } else {
12545  // struct/union/class
12546 
12547  // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
12548  // struct X { int A; } D; D should chain to X.
12549  if (getLangOpts().CPlusPlus) {
12550  // FIXME: Look for a way to use RecordDecl for simple structs.
12551  New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
12552  cast_or_null<CXXRecordDecl>(PrevDecl));
12553 
12554  if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
12555  StdBadAlloc = cast<CXXRecordDecl>(New);
12556  } else
12557  New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
12558  cast_or_null<RecordDecl>(PrevDecl));
12559  }
12560 
12561  // C++11 [dcl.type]p3:
12562  // A type-specifier-seq shall not define a class or enumeration [...].
12563  if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) {
12564  Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
12565  << Context.getTagDeclType(New);
12566  Invalid = true;
12567  }
12568 
12569  // Maybe add qualifier info.
12570  if (SS.isNotEmpty()) {
12571  if (SS.isSet()) {
12572  // If this is either a declaration or a definition, check the
12573  // nested-name-specifier against the current context. We don't do this
12574  // for explicit specializations, because they have similar checking
12575  // (with more specific diagnostics) in the call to
12576  // CheckMemberSpecialization, below.
12577  if (!isExplicitSpecialization &&
12578  (TUK == TUK_Definition || TUK == TUK_Declaration) &&
12579  diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc))
12580  Invalid = true;
12581 
12583  if (TemplateParameterLists.size() > 0) {
12584  New->setTemplateParameterListsInfo(Context, TemplateParameterLists);
12585  }
12586  }
12587  else
12588  Invalid = true;
12589  }
12590 
12591  if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
12592  // Add alignment attributes if necessary; these attributes are checked when
12593  // the ASTContext lays out the structure.
12594  //
12595  // It is important for implementing the correct semantics that this
12596  // happen here (in act on tag decl). The #pragma pack stack is
12597  // maintained as a result of parser callbacks which can occur at
12598  // many points during the parsing of a struct declaration (because
12599  // the #pragma tokens are effectively skipped over during the
12600  // parsing of the struct).
12601  if (TUK == TUK_Definition) {
12602  AddAlignmentAttributesForRecord(RD);
12603  AddMsStructLayoutForRecord(RD);
12604  }
12605  }
12606 
12607  if (ModulePrivateLoc.isValid()) {
12608  if (isExplicitSpecialization)
12609  Diag(New->getLocation(), diag::err_module_private_specialization)
12610  << 2
12611  << FixItHint::CreateRemoval(ModulePrivateLoc);
12612  // __module_private__ does not apply to local classes. However, we only
12613  // diagnose this as an error when the declaration specifiers are
12614  // freestanding. Here, we just ignore the __module_private__.
12615  else if (!SearchDC->isFunctionOrMethod())
12616  New->setModulePrivate();
12617  }
12618 
12619  // If this is a specialization of a member class (of a class template),
12620  // check the specialization.
12621  if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
12622  Invalid = true;
12623 
12624  // If we're declaring or defining a tag in function prototype scope in C,
12625  // note that this type can only be used within the function and add it to
12626  // the list of decls to inject into the function definition scope.
12627  if ((Name || Kind == TTK_Enum) &&
12628  getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
12629  if (getLangOpts().CPlusPlus) {
12630  // C++ [dcl.fct]p6:
12631  // Types shall not be defined in return or parameter types.
12632  if (TUK == TUK_Definition && !IsTypeSpecifier) {
12633  Diag(Loc, diag::err_type_defined_in_param_type)
12634  << Name;
12635  Invalid = true;
12636  }
12637  } else if (!PrevDecl) {
12638  Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
12639  }
12640  DeclsInPrototypeScope.push_back(New);
12641  }
12642 
12643  if (Invalid)
12644  New->setInvalidDecl();
12645 
12646  if (Attr)
12647  ProcessDeclAttributeList(S, New, Attr);
12648 
12649  // Set the lexical context. If the tag has a C++ scope specifier, the
12650  // lexical context will be different from the semantic context.
12651  New->setLexicalDeclContext(CurContext);
12652 
12653  // Mark this as a friend decl if applicable.
12654  // In Microsoft mode, a friend declaration also acts as a forward
12655  // declaration so we always pass true to setObjectOfFriendDecl to make
12656  // the tag name visible.
12657  if (TUK == TUK_Friend)
12658  New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
12659 
12660  // Set the access specifier.
12661  if (!Invalid && SearchDC->isRecord())
12662  SetMemberAccessSpecifier(New, PrevDecl, AS);
12663 
12664  if (TUK == TUK_Definition)
12665  New->startDefinition();
12666 
12667  // If this has an identifier, add it to the scope stack.
12668  if (TUK == TUK_Friend) {
12669  // We might be replacing an existing declaration in the lookup tables;
12670  // if so, borrow its access specifier.
12671  if (PrevDecl)
12672  New->setAccess(PrevDecl->getAccess());
12673 
12675  DC->makeDeclVisibleInContext(New);
12676  if (Name) // can be null along some error paths
12677  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
12678  PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
12679  } else if (Name) {
12680  S = getNonFieldDeclScope(S);
12681  PushOnScopeChains(New, S, !IsForwardReference);
12682  if (IsForwardReference)
12683  SearchDC->makeDeclVisibleInContext(New);
12684 
12685  } else {
12686  CurContext->addDecl(New);
12687  }
12688 
12689  // If this is the C FILE type, notify the AST context.
12690  if (IdentifierInfo *II = New->getIdentifier())
12691  if (!New->isInvalidDecl() &&
12693  II->isStr("FILE"))
12694  Context.setFILEDecl(New);
12695 
12696  if (PrevDecl)
12697  mergeDeclAttributes(New, PrevDecl);
12698 
12699  // If there's a #pragma GCC visibility in scope, set the visibility of this
12700  // record.
12701  AddPushedVisibilityAttribute(New);
12702 
12703  OwnedDecl = true;
12704  // In C++, don't return an invalid declaration. We can't recover well from
12705  // the cases where we make the type anonymous.
12706  return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New;
12707 }
12708 
12710  AdjustDeclIfTemplate(TagD);
12711  TagDecl *Tag = cast<TagDecl>(TagD);
12712 
12713  // Enter the tag context.
12714  PushDeclContext(S, Tag);
12715 
12716  ActOnDocumentableDecl(TagD);
12717 
12718  // If there's a #pragma GCC visibility in scope, set the visibility of this
12719  // record.
12720  AddPushedVisibilityAttribute(Tag);
12721 }
12722 
12724  assert(isa<ObjCContainerDecl>(IDecl) &&
12725  "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
12726  DeclContext *OCD = cast<DeclContext>(IDecl);
12727  assert(getContainingDC(OCD) == CurContext &&
12728  "The next DeclContext should be lexically contained in the current one.");
12729  CurContext = OCD;
12730  return IDecl;
12731 }
12732 
12734  SourceLocation FinalLoc,
12735  bool IsFinalSpelledSealed,
12736  SourceLocation LBraceLoc) {
12737  AdjustDeclIfTemplate(TagD);
12738  CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
12739 
12740  FieldCollector->StartClass();
12741 
12742  if (!Record->getIdentifier())
12743  return;
12744 
12745  if (FinalLoc.isValid())
12746  Record->addAttr(new (Context)
12747  FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
12748 
12749  // C++ [class]p2:
12750  // [...] The class-name is also inserted into the scope of the
12751  // class itself; this is known as the injected-class-name. For
12752  // purposes of access checking, the injected-class-name is treated
12753  // as if it were a public member name.
12754  CXXRecordDecl *InjectedClassName
12755  = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
12756  Record->getLocStart(), Record->getLocation(),
12757  Record->getIdentifier(),
12758  /*PrevDecl=*/nullptr,
12759  /*DelayTypeCreation=*/true);
12760  Context.getTypeDeclType(InjectedClassName, Record);
12761  InjectedClassName->setImplicit();
12762  InjectedClassName->setAccess(AS_public);
12763  if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
12764  InjectedClassName->setDescribedClassTemplate(Template);
12765  PushOnScopeChains(InjectedClassName, S);
12766  assert(InjectedClassName->isInjectedClassName() &&
12767  "Broken injected-class-name");
12768 }
12769 
12771  SourceLocation RBraceLoc) {
12772  AdjustDeclIfTemplate(TagD);
12773  TagDecl *Tag = cast<TagDecl>(TagD);
12774  Tag->setRBraceLoc(RBraceLoc);
12775 
12776  // Make sure we "complete" the definition even it is invalid.
12777  if (Tag->isBeingDefined()) {
12778  assert(Tag->isInvalidDecl() && "We should already have completed it");
12779  if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12780  RD->completeDefinition();
12781  }
12782 
12783  if (isa<CXXRecordDecl>(Tag))
12784  FieldCollector->FinishClass();
12785 
12786  // Exit this scope of this tag's definition.
12787  PopDeclContext();
12788 
12789  if (getCurLexicalContext()->isObjCContainer() &&
12790  Tag->getDeclContext()->isFileContext())
12792 
12793  // Notify the consumer that we've defined a tag.
12794  if (!Tag->isInvalidDecl())
12795  Consumer.HandleTagDeclDefinition(Tag);
12796 }
12797 
12799  // Exit this scope of this interface definition.
12800  PopDeclContext();
12801 }
12802 
12804  assert(DC == CurContext && "Mismatch of container contexts");
12805  OriginalLexicalContext = DC;
12806  ActOnObjCContainerFinishDefinition();
12807 }
12808 
12810  ActOnObjCContainerStartDefinition(cast<Decl>(DC));
12811  OriginalLexicalContext = nullptr;
12812 }
12813 
12815  AdjustDeclIfTemplate(TagD);
12816  TagDecl *Tag = cast<TagDecl>(TagD);
12817  Tag->setInvalidDecl();
12818 
12819  // Make sure we "complete" the definition even it is invalid.
12820  if (Tag->isBeingDefined()) {
12821  if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12822  RD->completeDefinition();
12823  }
12824 
12825  // We're undoing ActOnTagStartDefinition here, not
12826  // ActOnStartCXXMemberDeclarations, so we don't have to mess with
12827  // the FieldCollector.
12828 
12829  PopDeclContext();
12830 }
12831 
12832 // Note that FieldName may be null for anonymous bitfields.
12834  IdentifierInfo *FieldName,
12835  QualType FieldTy, bool IsMsStruct,
12836  Expr *BitWidth, bool *ZeroWidth) {
12837  // Default to true; that shouldn't confuse checks for emptiness
12838  if (ZeroWidth)
12839  *ZeroWidth = true;
12840 
12841  // C99 6.7.2.1p4 - verify the field type.
12842  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
12843  if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
12844  // Handle incomplete types with specific error.
12845  if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
12846  return ExprError();
12847  if (FieldName)
12848  return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
12849  << FieldName << FieldTy << BitWidth->getSourceRange();
12850  return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
12851  << FieldTy << BitWidth->getSourceRange();
12852  } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
12853  UPPC_BitFieldWidth))
12854  return ExprError();
12855 
12856  // If the bit-width is type- or value-dependent, don't try to check
12857  // it now.
12858  if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
12859  return BitWidth;
12860 
12861  llvm::APSInt Value;
12862  ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
12863  if (ICE.isInvalid())
12864  return ICE;
12865  BitWidth = ICE.get();
12866 
12867  if (Value != 0 && ZeroWidth)
12868  *ZeroWidth = false;
12869 
12870  // Zero-width bitfield is ok for anonymous field.
12871  if (Value == 0 && FieldName)
12872  return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
12873 
12874  if (Value.isSigned() && Value.isNegative()) {
12875  if (FieldName)
12876  return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
12877  << FieldName << Value.toString(10);
12878  return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
12879  << Value.toString(10);
12880  }
12881 
12882  if (!FieldTy->isDependentType()) {
12883  uint64_t TypeStorageSize = Context.getTypeSize(FieldTy);
12884  uint64_t TypeWidth = Context.getIntWidth(FieldTy);
12885  bool BitfieldIsOverwide = Value.ugt(TypeWidth);
12886 
12887  // Over-wide bitfields are an error in C or when using the MSVC bitfield
12888  // ABI.
12889  bool CStdConstraintViolation =
12890  BitfieldIsOverwide && !getLangOpts().CPlusPlus;
12891  bool MSBitfieldViolation =
12892  Value.ugt(TypeStorageSize) &&
12893  (IsMsStruct || Context.getTargetInfo().getCXXABI().isMicrosoft());
12894  if (CStdConstraintViolation || MSBitfieldViolation) {
12895  unsigned DiagWidth =
12896  CStdConstraintViolation ? TypeWidth : TypeStorageSize;
12897  if (FieldName)
12898  return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_width)
12899  << FieldName << (unsigned)Value.getZExtValue()
12900  << !CStdConstraintViolation << DiagWidth;
12901 
12902  return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_width)
12903  << (unsigned)Value.getZExtValue() << !CStdConstraintViolation
12904  << DiagWidth;
12905  }
12906 
12907  // Warn on types where the user might conceivably expect to get all
12908  // specified bits as value bits: that's all integral types other than
12909  // 'bool'.
12910  if (BitfieldIsOverwide && !FieldTy->isBooleanType()) {
12911  if (FieldName)
12912  Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width)
12913  << FieldName << (unsigned)Value.getZExtValue()
12914  << (unsigned)TypeWidth;
12915  else
12916  Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_width)
12917  << (unsigned)Value.getZExtValue() << (unsigned)TypeWidth;
12918  }
12919  }
12920 
12921  return BitWidth;
12922 }
12923 
12924 /// ActOnField - Each field of a C struct/union is passed into this in order
12925 /// to create a FieldDecl object for it.
12927  Declarator &D, Expr *BitfieldWidth) {
12928  FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
12929  DeclStart, D, static_cast<Expr*>(BitfieldWidth),
12930  /*InitStyle=*/ICIS_NoInit, AS_public);
12931  return Res;
12932 }
12933 
12934 /// HandleField - Analyze a field of a C struct or a C++ data member.
12935 ///
12937  SourceLocation DeclStart,
12938  Declarator &D, Expr *BitWidth,
12939  InClassInitStyle InitStyle,
12940  AccessSpecifier AS) {
12941  IdentifierInfo *II = D.getIdentifier();
12942  SourceLocation Loc = DeclStart;
12943  if (II) Loc = D.getIdentifierLoc();
12944 
12945  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12946  QualType T = TInfo->getType();
12947  if (getLangOpts().CPlusPlus) {
12948  CheckExtraCXXDefaultArguments(D);
12949 
12950  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
12951  UPPC_DataMemberType)) {
12952  D.setInvalidType();
12953  T = Context.IntTy;
12954  TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
12955  }
12956  }
12957 
12958  // TR 18037 does not allow fields to be declared with address spaces.
12959  if (T.getQualifiers().hasAddressSpace()) {
12960  Diag(Loc, diag::err_field_with_address_space);
12961  D.setInvalidType();
12962  }
12963 
12964  // OpenCL 1.2 spec, s6.9 r:
12965  // The event type cannot be used to declare a structure or union field.
12966  if (LangOpts.OpenCL && T->isEventT()) {
12967  Diag(Loc, diag::err_event_t_struct_field);
12968  D.setInvalidType();
12969  }
12970 
12971  DiagnoseFunctionSpecifiers(D.getDeclSpec());
12972 
12975  diag::err_invalid_thread)
12976  << DeclSpec::getSpecifierName(TSCS);
12977 
12978  // Check to see if this name was declared as a member previously
12979  NamedDecl *PrevDecl = nullptr;
12980  LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
12981  LookupName(Previous, S);
12982  switch (Previous.getResultKind()) {
12983  case LookupResult::Found:
12985  PrevDecl = Previous.getAsSingle<NamedDecl>();
12986  break;
12987 
12989  PrevDecl = Previous.getRepresentativeDecl();
12990  break;
12991 
12995  break;
12996  }
12997  Previous.suppressDiagnostics();
12998 
12999  if (PrevDecl && PrevDecl->isTemplateParameter()) {
13000  // Maybe we will complain about the shadowed template parameter.
13001  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
13002  // Just pretend that we didn't see the previous declaration.
13003  PrevDecl = nullptr;
13004  }
13005 
13006  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
13007  PrevDecl = nullptr;
13008 
13009  bool Mutable
13011  SourceLocation TSSL = D.getLocStart();
13012  FieldDecl *NewFD
13013  = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
13014  TSSL, AS, PrevDecl, &D);
13015 
13016  if (NewFD->isInvalidDecl())
13017  Record->setInvalidDecl();
13018 
13020  NewFD->setModulePrivate();
13021 
13022  if (NewFD->isInvalidDecl() && PrevDecl) {
13023  // Don't introduce NewFD into scope; there's already something
13024  // with the same name in the same scope.
13025  } else if (II) {
13026  PushOnScopeChains(NewFD, S);
13027  } else
13028  Record->addDecl(NewFD);
13029 
13030  return NewFD;
13031 }
13032 
13033 /// \brief Build a new FieldDecl and check its well-formedness.
13034 ///
13035 /// This routine builds a new FieldDecl given the fields name, type,
13036 /// record, etc. \p PrevDecl should refer to any previous declaration
13037 /// with the same name and in the same scope as the field to be
13038 /// created.
13039 ///
13040 /// \returns a new FieldDecl.
13041 ///
13042 /// \todo The Declarator argument is a hack. It will be removed once
13044  TypeSourceInfo *TInfo,
13045  RecordDecl *Record, SourceLocation Loc,
13046  bool Mutable, Expr *BitWidth,
13047  InClassInitStyle InitStyle,
13048  SourceLocation TSSL,
13049  AccessSpecifier AS, NamedDecl *PrevDecl,
13050  Declarator *D) {
13051  IdentifierInfo *II = Name.getAsIdentifierInfo();
13052  bool InvalidDecl = false;
13053  if (D) InvalidDecl = D->isInvalidType();
13054 
13055  // If we receive a broken type, recover by assuming 'int' and
13056  // marking this declaration as invalid.
13057  if (T.isNull()) {
13058  InvalidDecl = true;
13059  T = Context.IntTy;
13060  }
13061 
13062  QualType EltTy = Context.getBaseElementType(T);
13063  if (!EltTy->isDependentType()) {
13064  if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
13065  // Fields of incomplete type force their record to be invalid.
13066  Record->setInvalidDecl();
13067  InvalidDecl = true;
13068  } else {
13069  NamedDecl *Def;
13070  EltTy->isIncompleteType(&Def);
13071  if (Def && Def->isInvalidDecl()) {
13072  Record->setInvalidDecl();
13073  InvalidDecl = true;
13074  }
13075  }
13076  }
13077 
13078  // OpenCL v1.2 s6.9.c: bitfields are not supported.
13079  if (BitWidth && getLangOpts().OpenCL) {
13080  Diag(Loc, diag::err_opencl_bitfields);
13081  InvalidDecl = true;
13082  }
13083 
13084  // C99 6.7.2.1p8: A member of a structure or union may have any type other
13085  // than a variably modified type.
13086  if (!InvalidDecl && T->isVariablyModifiedType()) {
13087  bool SizeIsNegative;
13088  llvm::APSInt Oversized;
13089 
13090  TypeSourceInfo *FixedTInfo =
13092  SizeIsNegative,
13093  Oversized);
13094  if (FixedTInfo) {
13095  Diag(Loc, diag::warn_illegal_constant_array_size);
13096  TInfo = FixedTInfo;
13097  T = FixedTInfo->getType();
13098  } else {
13099  if (SizeIsNegative)
13100  Diag(Loc, diag::err_typecheck_negative_array_size);
13101  else if (Oversized.getBoolValue())
13102  Diag(Loc, diag::err_array_too_large)
13103  << Oversized.toString(10);
13104  else
13105  Diag(Loc, diag::err_typecheck_field_variable_size);
13106  InvalidDecl = true;
13107  }
13108  }
13109 
13110  // Fields can not have abstract class types
13111  if (!InvalidDecl && RequireNonAbstractType(Loc, T,
13112  diag::err_abstract_type_in_decl,
13113  AbstractFieldType))
13114  InvalidDecl = true;
13115 
13116  bool ZeroWidth = false;
13117  if (InvalidDecl)
13118  BitWidth = nullptr;
13119  // If this is declared as a bit-field, check the bit-field.
13120  if (BitWidth) {
13121  BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
13122  &ZeroWidth).get();
13123  if (!BitWidth) {
13124  InvalidDecl = true;
13125  BitWidth = nullptr;
13126  ZeroWidth = false;
13127  }
13128  }
13129 
13130  // Check that 'mutable' is consistent with the type of the declaration.
13131  if (!InvalidDecl && Mutable) {
13132  unsigned DiagID = 0;
13133  if (T->isReferenceType())
13134  DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference
13135  : diag::err_mutable_reference;
13136  else if (T.isConstQualified())
13137  DiagID = diag::err_mutable_const;
13138 
13139  if (DiagID) {
13140  SourceLocation ErrLoc = Loc;
13141  if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
13142  ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
13143  Diag(ErrLoc, DiagID);
13144  if (DiagID != diag::ext_mutable_reference) {
13145  Mutable = false;
13146  InvalidDecl = true;
13147  }
13148  }
13149  }
13150 
13151  // C++11 [class.union]p8 (DR1460):
13152  // At most one variant member of a union may have a
13153  // brace-or-equal-initializer.
13154  if (InitStyle != ICIS_NoInit)
13155  checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
13156 
13157  FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
13158  BitWidth, Mutable, InitStyle);
13159  if (InvalidDecl)
13160  NewFD->setInvalidDecl();
13161 
13162  if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
13163  Diag(Loc, diag::err_duplicate_member) << II;
13164  Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
13165  NewFD->setInvalidDecl();
13166  }
13167 
13168  if (!InvalidDecl && getLangOpts().CPlusPlus) {
13169  if (Record->isUnion()) {
13170  if (const RecordType *RT = EltTy->getAs<RecordType>()) {
13171  CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
13172  if (RDecl->getDefinition()) {
13173  // C++ [class.union]p1: An object of a class with a non-trivial
13174  // constructor, a non-trivial copy constructor, a non-trivial
13175  // destructor, or a non-trivial copy assignment operator
13176  // cannot be a member of a union, nor can an array of such
13177  // objects.
13178  if (CheckNontrivialField(NewFD))
13179  NewFD->setInvalidDecl();
13180  }
13181  }
13182 
13183  // C++ [class.union]p1: If a union contains a member of reference type,
13184  // the program is ill-formed, except when compiling with MSVC extensions
13185  // enabled.
13186  if (EltTy->isReferenceType()) {
13187  Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
13188  diag::ext_union_member_of_reference_type :
13189  diag::err_union_member_of_reference_type)
13190  << NewFD->getDeclName() << EltTy;
13191  if (!getLangOpts().MicrosoftExt)
13192  NewFD->setInvalidDecl();
13193  }
13194  }
13195  }
13196 
13197  // FIXME: We need to pass in the attributes given an AST
13198  // representation, not a parser representation.
13199  if (D) {
13200  // FIXME: The current scope is almost... but not entirely... correct here.
13201  ProcessDeclAttributes(getCurScope(), NewFD, *D);
13202 
13203  if (NewFD->hasAttrs())
13204  CheckAlignasUnderalignment(NewFD);
13205  }
13206 
13207  // In auto-retain/release, infer strong retension for fields of
13208  // retainable type.
13209  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
13210  NewFD->setInvalidDecl();
13211 
13212  if (T.isObjCGCWeak())
13213  Diag(Loc, diag::warn_attribute_weak_on_field);
13214 
13215  NewFD->setAccess(AS);
13216  return NewFD;
13217 }
13218 
13220  assert(FD);
13221  assert(getLangOpts().CPlusPlus && "valid check only for C++");
13222 
13223  if (FD->isInvalidDecl() || FD->getType()->isDependentType())
13224  return false;
13225 
13226  QualType EltTy = Context.getBaseElementType(FD->getType());
13227  if (const RecordType *RT = EltTy->getAs<RecordType>()) {
13228  CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
13229  if (RDecl->getDefinition()) {
13230  // We check for copy constructors before constructors
13231  // because otherwise we'll never get complaints about
13232  // copy constructors.
13233 
13234  CXXSpecialMember member = CXXInvalid;
13235  // We're required to check for any non-trivial constructors. Since the
13236  // implicit default constructor is suppressed if there are any
13237  // user-declared constructors, we just need to check that there is a
13238  // trivial default constructor and a trivial copy constructor. (We don't
13239  // worry about move constructors here, since this is a C++98 check.)
13240  if (RDecl->hasNonTrivialCopyConstructor())
13241  member = CXXCopyConstructor;
13242  else if (!RDecl->hasTrivialDefaultConstructor())
13243  member = CXXDefaultConstructor;
13244  else if (RDecl->hasNonTrivialCopyAssignment())
13245  member = CXXCopyAssignment;
13246  else if (RDecl->hasNonTrivialDestructor())
13247  member = CXXDestructor;
13248 
13249  if (member != CXXInvalid) {
13250  if (!getLangOpts().CPlusPlus11 &&
13251  getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
13252  // Objective-C++ ARC: it is an error to have a non-trivial field of
13253  // a union. However, system headers in Objective-C programs
13254  // occasionally have Objective-C lifetime objects within unions,
13255  // and rather than cause the program to fail, we make those
13256  // members unavailable.
13257  SourceLocation Loc = FD->getLocation();
13258  if (getSourceManager().isInSystemHeader(Loc)) {
13259  if (!FD->hasAttr<UnavailableAttr>())
13260  FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
13261  UnavailableAttr::IR_ARCFieldWithOwnership, Loc));
13262  return false;
13263  }
13264  }
13265 
13266  Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
13267  diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
13268  diag::err_illegal_union_or_anon_struct_member)
13269  << FD->getParent()->isUnion() << FD->getDeclName() << member;
13270  DiagnoseNontrivial(RDecl, member);
13271  return !getLangOpts().CPlusPlus11;
13272  }
13273  }
13274  }
13275 
13276  return false;
13277 }
13278 
13279 /// TranslateIvarVisibility - Translate visibility from a token ID to an
13280 /// AST enum value.
13283  switch (ivarVisibility) {
13284  default: llvm_unreachable("Unknown visitibility kind");
13285  case tok::objc_private: return ObjCIvarDecl::Private;
13286  case tok::objc_public: return ObjCIvarDecl::Public;
13287  case tok::objc_protected: return ObjCIvarDecl::Protected;
13288  case tok::objc_package: return ObjCIvarDecl::Package;
13289  }
13290 }
13291 
13292 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
13293 /// in order to create an IvarDecl object for it.
13295  SourceLocation DeclStart,
13296  Declarator &D, Expr *BitfieldWidth,
13298 
13299  IdentifierInfo *II = D.getIdentifier();
13300  Expr *BitWidth = (Expr*)BitfieldWidth;
13301  SourceLocation Loc = DeclStart;
13302  if (II) Loc = D.getIdentifierLoc();
13303 
13304  // FIXME: Unnamed fields can be handled in various different ways, for
13305  // example, unnamed unions inject all members into the struct namespace!
13306 
13307  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
13308  QualType T = TInfo->getType();
13309 
13310  if (BitWidth) {
13311  // 6.7.2.1p3, 6.7.2.1p4
13312  BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
13313  if (!BitWidth)
13314  D.setInvalidType();
13315  } else {
13316  // Not a bitfield.
13317 
13318  // validate II.
13319 
13320  }
13321  if (T->isReferenceType()) {
13322  Diag(Loc, diag::err_ivar_reference_type);
13323  D.setInvalidType();
13324  }
13325  // C99 6.7.2.1p8: A member of a structure or union may have any type other
13326  // than a variably modified type.
13327  else if (T->isVariablyModifiedType()) {
13328  Diag(Loc, diag::err_typecheck_ivar_variable_size);
13329  D.setInvalidType();
13330  }
13331 
13332  // Get the visibility (access control) for this ivar.
13334  Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
13336  // Must set ivar's DeclContext to its enclosing interface.
13337  ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
13338  if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
13339  return nullptr;
13340  ObjCContainerDecl *EnclosingContext;
13341  if (ObjCImplementationDecl *IMPDecl =
13342  dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
13343  if (LangOpts.ObjCRuntime.isFragile()) {
13344  // Case of ivar declared in an implementation. Context is that of its class.
13345  EnclosingContext = IMPDecl->getClassInterface();
13346  assert(EnclosingContext && "Implementation has no class interface!");
13347  }
13348  else
13349  EnclosingContext = EnclosingDecl;
13350  } else {
13351  if (ObjCCategoryDecl *CDecl =
13352  dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
13353  if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
13354  Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
13355  return nullptr;
13356  }
13357  }
13358  EnclosingContext = EnclosingDecl;
13359  }
13360 
13361  // Construct the decl.
13362  ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
13363  DeclStart, Loc, II, T,
13364  TInfo, ac, (Expr *)BitfieldWidth);
13365 
13366  if (II) {
13367  NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
13368  ForRedeclaration);
13369  if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
13370  && !isa<TagDecl>(PrevDecl)) {
13371  Diag(Loc, diag::err_duplicate_member) << II;
13372  Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
13373  NewID->setInvalidDecl();
13374  }
13375  }
13376 
13377  // Process attributes attached to the ivar.
13378  ProcessDeclAttributes(S, NewID, D);
13379 
13380  if (D.isInvalidType())
13381  NewID->setInvalidDecl();
13382 
13383  // In ARC, infer 'retaining' for ivars of retainable type.
13384  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
13385  NewID->setInvalidDecl();
13386 
13388  NewID->setModulePrivate();
13389 
13390  if (II) {
13391  // FIXME: When interfaces are DeclContexts, we'll need to add
13392  // these to the interface.
13393  S->AddDecl(NewID);
13394  IdResolver.AddDecl(NewID);
13395  }
13396 
13397  if (LangOpts.ObjCRuntime.isNonFragile() &&
13398  !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
13399  Diag(Loc, diag::warn_ivars_in_interface);
13400 
13401  return NewID;
13402 }
13403 
13404 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for
13405 /// class and class extensions. For every class \@interface and class
13406 /// extension \@interface, if the last ivar is a bitfield of any type,
13407 /// then add an implicit `char :0` ivar to the end of that interface.
13409  SmallVectorImpl<Decl *> &AllIvarDecls) {
13410  if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
13411  return;
13412 
13413  Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
13414  ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
13415 
13416  if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
13417  return;
13418  ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
13419  if (!ID) {
13420  if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
13421  if (!CD->IsClassExtension())
13422  return;
13423  }
13424  // No need to add this to end of @implementation.
13425  else
13426  return;
13427  }
13428  // All conditions are met. Add a new bitfield to the tail end of ivars.
13429  llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
13430  Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
13431 
13432  Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
13433  DeclLoc, DeclLoc, nullptr,
13434  Context.CharTy,
13436  DeclLoc),
13438  true);
13439  AllIvarDecls.push_back(Ivar);
13440 }
13441 
13442 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
13443  ArrayRef<Decl *> Fields, SourceLocation LBrac,
13444  SourceLocation RBrac, AttributeList *Attr) {
13445  assert(EnclosingDecl && "missing record or interface decl");
13446 
13447  // If this is an Objective-C @implementation or category and we have
13448  // new fields here we should reset the layout of the interface since
13449  // it will now change.
13450  if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
13451  ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
13452  switch (DC->getKind()) {
13453  default: break;
13454  case Decl::ObjCCategory:
13455  Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
13456  break;
13457  case Decl::ObjCImplementation:
13458  Context.
13459  ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
13460  break;
13461  }
13462  }
13463 
13464  RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
13465 
13466  // Start counting up the number of named members; make sure to include
13467  // members of anonymous structs and unions in the total.
13468  unsigned NumNamedMembers = 0;
13469  if (Record) {
13470  for (const auto *I : Record->decls()) {
13471  if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
13472  if (IFD->getDeclName())
13473  ++NumNamedMembers;
13474  }
13475  }
13476 
13477  // Verify that all the fields are okay.
13478  SmallVector<FieldDecl*, 32> RecFields;
13479 
13480  bool ARCErrReported = false;
13481  for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
13482  i != end; ++i) {
13483  FieldDecl *FD = cast<FieldDecl>(*i);
13484 
13485  // Get the type for the field.
13486  const Type *FDTy = FD->getType().getTypePtr();
13487 
13488  if (!FD->isAnonymousStructOrUnion()) {
13489  // Remember all fields written by the user.
13490  RecFields.push_back(FD);
13491  }
13492 
13493  // If the field is already invalid for some reason, don't emit more
13494  // diagnostics about it.
13495  if (FD->isInvalidDecl()) {
13496  EnclosingDecl->setInvalidDecl();
13497  continue;
13498  }
13499 
13500  // C99 6.7.2.1p2:
13501  // A structure or union shall not contain a member with
13502  // incomplete or function type (hence, a structure shall not
13503  // contain an instance of itself, but may contain a pointer to
13504  // an instance of itself), except that the last member of a
13505  // structure with more than one named member may have incomplete
13506  // array type; such a structure (and any union containing,
13507  // possibly recursively, a member that is such a structure)
13508  // shall not be a member of a structure or an element of an
13509  // array.
13510  if (FDTy->isFunctionType()) {
13511  // Field declared as a function.
13512  Diag(FD->getLocation(), diag::err_field_declared_as_function)
13513  << FD->getDeclName();
13514  FD->setInvalidDecl();
13515  EnclosingDecl->setInvalidDecl();
13516  continue;
13517  } else if (FDTy->isIncompleteArrayType() && Record &&
13518  ((i + 1 == Fields.end() && !Record->isUnion()) ||
13519  ((getLangOpts().MicrosoftExt ||
13520  getLangOpts().CPlusPlus) &&
13521  (i + 1 == Fields.end() || Record->isUnion())))) {
13522  // Flexible array member.
13523  // Microsoft and g++ is more permissive regarding flexible array.
13524  // It will accept flexible array in union and also
13525  // as the sole element of a struct/class.
13526  unsigned DiagID = 0;
13527  if (Record->isUnion())
13528  DiagID = getLangOpts().MicrosoftExt
13529  ? diag::ext_flexible_array_union_ms
13530  : getLangOpts().CPlusPlus
13531  ? diag::ext_flexible_array_union_gnu
13532  : diag::err_flexible_array_union;
13533  else if (Fields.size() == 1)
13534  DiagID = getLangOpts().MicrosoftExt
13535  ? diag::ext_flexible_array_empty_aggregate_ms
13536  : getLangOpts().CPlusPlus
13537  ? diag::ext_flexible_array_empty_aggregate_gnu
13538  : NumNamedMembers < 1
13539  ? diag::err_flexible_array_empty_aggregate
13540  : 0;
13541 
13542  if (DiagID)
13543  Diag(FD->getLocation(), DiagID) << FD->getDeclName()
13544  << Record->getTagKind();
13545  // While the layout of types that contain virtual bases is not specified
13546  // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
13547  // virtual bases after the derived members. This would make a flexible
13548  // array member declared at the end of an object not adjacent to the end
13549  // of the type.
13550  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record))
13551  if (RD->getNumVBases() != 0)
13552  Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
13553  << FD->getDeclName() << Record->getTagKind();
13554  if (!getLangOpts().C99)
13555  Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
13556  << FD->getDeclName() << Record->getTagKind();
13557 
13558  // If the element type has a non-trivial destructor, we would not
13559  // implicitly destroy the elements, so disallow it for now.
13560  //
13561  // FIXME: GCC allows this. We should probably either implicitly delete
13562  // the destructor of the containing class, or just allow this.
13563  QualType BaseElem = Context.getBaseElementType(FD->getType());
13564  if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
13565  Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
13566  << FD->getDeclName() << FD->getType();
13567  FD->setInvalidDecl();
13568  EnclosingDecl->setInvalidDecl();
13569  continue;
13570  }
13571  // Okay, we have a legal flexible array member at the end of the struct.
13572  Record->setHasFlexibleArrayMember(true);
13573  } else if (!FDTy->isDependentType() &&
13574  RequireCompleteType(FD->getLocation(), FD->getType(),
13575  diag::err_field_incomplete)) {
13576  // Incomplete type
13577  FD->setInvalidDecl();
13578  EnclosingDecl->setInvalidDecl();
13579  continue;
13580  } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
13581  if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
13582  // A type which contains a flexible array member is considered to be a
13583  // flexible array member.
13584  Record->setHasFlexibleArrayMember(true);
13585  if (!Record->isUnion()) {
13586  // If this is a struct/class and this is not the last element, reject
13587  // it. Note that GCC supports variable sized arrays in the middle of
13588  // structures.
13589  if (i + 1 != Fields.end())
13590  Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
13591  << FD->getDeclName() << FD->getType();
13592  else {
13593  // We support flexible arrays at the end of structs in
13594  // other structs as an extension.
13595  Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
13596  << FD->getDeclName();
13597  }
13598  }
13599  }
13600  if (isa<ObjCContainerDecl>(EnclosingDecl) &&
13601  RequireNonAbstractType(FD->getLocation(), FD->getType(),
13602  diag::err_abstract_type_in_decl,
13603  AbstractIvarType)) {
13604  // Ivars can not have abstract class types
13605  FD->setInvalidDecl();
13606  }
13607  if (Record && FDTTy->getDecl()->hasObjectMember())
13608  Record->setHasObjectMember(true);
13609  if (Record && FDTTy->getDecl()->hasVolatileMember())
13610  Record->setHasVolatileMember(true);
13611  } else if (FDTy->isObjCObjectType()) {
13612  /// A field cannot be an Objective-c object
13613  Diag(FD->getLocation(), diag::err_statically_allocated_object)
13614  << FixItHint::CreateInsertion(FD->getLocation(), "*");
13616  FD->setType(T);
13617  } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
13618  (!getLangOpts().CPlusPlus || Record->isUnion())) {
13619  // It's an error in ARC if a field has lifetime.
13620  // We don't want to report this in a system header, though,
13621  // so we just make the field unavailable.
13622  // FIXME: that's really not sufficient; we need to make the type
13623  // itself invalid to, say, initialize or copy.
13624  QualType T = FD->getType();
13626  if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
13627  SourceLocation loc = FD->getLocation();
13628  if (getSourceManager().isInSystemHeader(loc)) {
13629  if (!FD->hasAttr<UnavailableAttr>()) {
13630  FD->addAttr(UnavailableAttr::CreateImplicit(Context, "",
13631  UnavailableAttr::IR_ARCFieldWithOwnership, loc));
13632  }
13633  } else {
13634  Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
13635  << T->isBlockPointerType() << Record->getTagKind();
13636  }
13637  ARCErrReported = true;
13638  }
13639  } else if (getLangOpts().ObjC1 &&
13640  getLangOpts().getGC() != LangOptions::NonGC &&
13641  Record && !Record->hasObjectMember()) {
13642  if (FD->getType()->isObjCObjectPointerType() ||
13643  FD->getType().isObjCGCStrong())
13644  Record->setHasObjectMember(true);
13645  else if (Context.getAsArrayType(FD->getType())) {
13646  QualType BaseType = Context.getBaseElementType(FD->getType());
13647  if (BaseType->isRecordType() &&
13648  BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
13649  Record->setHasObjectMember(true);
13650  else if (BaseType->isObjCObjectPointerType() ||
13651  BaseType.isObjCGCStrong())
13652  Record->setHasObjectMember(true);
13653  }
13654  }
13655  if (Record && FD->getType().isVolatileQualified())
13656  Record->setHasVolatileMember(true);
13657  // Keep track of the number of named members.
13658  if (FD->getIdentifier())
13659  ++NumNamedMembers;
13660  }
13661 
13662  // Okay, we successfully defined 'Record'.
13663  if (Record) {
13664  bool Completed = false;
13665  if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
13666  if (!CXXRecord->isInvalidDecl()) {
13667  // Set access bits correctly on the directly-declared conversions.
13669  I = CXXRecord->conversion_begin(),
13670  E = CXXRecord->conversion_end(); I != E; ++I)
13671  I.setAccess((*I)->getAccess());
13672 
13673  if (!CXXRecord->isDependentType()) {
13674  if (CXXRecord->hasUserDeclaredDestructor()) {
13675  // Adjust user-defined destructor exception spec.
13676  if (getLangOpts().CPlusPlus11)
13677  AdjustDestructorExceptionSpec(CXXRecord,
13678  CXXRecord->getDestructor());
13679  }
13680 
13681  // Add any implicitly-declared members to this class.
13682  AddImplicitlyDeclaredMembersToClass(CXXRecord);
13683 
13684  // If we have virtual base classes, we may end up finding multiple
13685  // final overriders for a given virtual function. Check for this
13686  // problem now.
13687  if (CXXRecord->getNumVBases()) {
13688  CXXFinalOverriderMap FinalOverriders;
13689  CXXRecord->getFinalOverriders(FinalOverriders);
13690 
13691  for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
13692  MEnd = FinalOverriders.end();
13693  M != MEnd; ++M) {
13694  for (OverridingMethods::iterator SO = M->second.begin(),
13695  SOEnd = M->second.end();
13696  SO != SOEnd; ++SO) {
13697  assert(SO->second.size() > 0 &&
13698  "Virtual function without overridding functions?");
13699  if (SO->second.size() == 1)
13700  continue;
13701 
13702  // C++ [class.virtual]p2:
13703  // In a derived class, if a virtual member function of a base
13704  // class subobject has more than one final overrider the
13705  // program is ill-formed.
13706  Diag(Record->getLocation(), diag::err_multiple_final_overriders)
13707  << (const NamedDecl *)M->first << Record;
13708  Diag(M->first->getLocation(),
13709  diag::note_overridden_virtual_function);
13711  OM = SO->second.begin(),
13712  OMEnd = SO->second.end();
13713  OM != OMEnd; ++OM)
13714  Diag(OM->Method->getLocation(), diag::note_final_overrider)
13715  << (const NamedDecl *)M->first << OM->Method->getParent();
13716 
13717  Record->setInvalidDecl();
13718  }
13719  }
13720  CXXRecord->completeDefinition(&FinalOverriders);
13721  Completed = true;
13722  }
13723  }
13724  }
13725  }
13726 
13727  if (!Completed)
13728  Record->completeDefinition();
13729 
13730  if (Record->hasAttrs()) {
13731  CheckAlignasUnderalignment(Record);
13732 
13733  if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
13734  checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
13735  IA->getRange(), IA->getBestCase(),
13736  IA->getSemanticSpelling());
13737  }
13738 
13739  // Check if the structure/union declaration is a type that can have zero
13740  // size in C. For C this is a language extension, for C++ it may cause
13741  // compatibility problems.
13742  bool CheckForZeroSize;
13743  if (!getLangOpts().CPlusPlus) {
13744  CheckForZeroSize = true;
13745  } else {
13746  // For C++ filter out types that cannot be referenced in C code.
13747  CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
13748  CheckForZeroSize =
13749  CXXRecord->getLexicalDeclContext()->isExternCContext() &&
13750  !CXXRecord->isDependentType() &&
13751  CXXRecord->isCLike();
13752  }
13753  if (CheckForZeroSize) {
13754  bool ZeroSize = true;
13755  bool IsEmpty = true;
13756  unsigned NonBitFields = 0;
13757  for (RecordDecl::field_iterator I = Record->field_begin(),
13758  E = Record->field_end();
13759  (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
13760  IsEmpty = false;
13761  if (I->isUnnamedBitfield()) {
13762  if (I->getBitWidthValue(Context) > 0)
13763  ZeroSize = false;
13764  } else {
13765  ++NonBitFields;
13766  QualType FieldType = I->getType();
13767  if (FieldType->isIncompleteType() ||
13768  !Context.getTypeSizeInChars(FieldType).isZero())
13769  ZeroSize = false;
13770  }
13771  }
13772 
13773  // Empty structs are an extension in C (C99 6.7.2.1p7). They are
13774  // allowed in C++, but warn if its declaration is inside
13775  // extern "C" block.
13776  if (ZeroSize) {
13777  Diag(RecLoc, getLangOpts().CPlusPlus ?
13778  diag::warn_zero_size_struct_union_in_extern_c :
13779  diag::warn_zero_size_struct_union_compat)
13780  << IsEmpty << Record->isUnion() << (NonBitFields > 1);
13781  }
13782 
13783  // Structs without named members are extension in C (C99 6.7.2.1p7),
13784  // but are accepted by GCC.
13785  if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
13786  Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
13787  diag::ext_no_named_members_in_struct_union)
13788  << Record->isUnion();
13789  }
13790  }
13791  } else {
13792  ObjCIvarDecl **ClsFields =
13793  reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
13794  if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
13795  ID->setEndOfDefinitionLoc(RBrac);
13796  // Add ivar's to class's DeclContext.
13797  for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
13798  ClsFields[i]->setLexicalDeclContext(ID);
13799  ID->addDecl(ClsFields[i]);
13800  }
13801  // Must enforce the rule that ivars in the base classes may not be
13802  // duplicates.
13803  if (ID->getSuperClass())
13804  DiagnoseDuplicateIvars(ID, ID->getSuperClass());
13805  } else if (ObjCImplementationDecl *IMPDecl =
13806  dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
13807  assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
13808  for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
13809  // Ivar declared in @implementation never belongs to the implementation.
13810  // Only it is in implementation's lexical context.
13811  ClsFields[I]->setLexicalDeclContext(IMPDecl);
13812  CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
13813  IMPDecl->setIvarLBraceLoc(LBrac);
13814  IMPDecl->setIvarRBraceLoc(RBrac);
13815  } else if (ObjCCategoryDecl *CDecl =
13816  dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
13817  // case of ivars in class extension; all other cases have been
13818  // reported as errors elsewhere.
13819  // FIXME. Class extension does not have a LocEnd field.
13820  // CDecl->setLocEnd(RBrac);
13821  // Add ivar's to class extension's DeclContext.
13822  // Diagnose redeclaration of private ivars.
13823  ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
13824  for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
13825  if (IDecl) {
13826  if (const ObjCIvarDecl *ClsIvar =
13827  IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
13828  Diag(ClsFields[i]->getLocation(),
13829  diag::err_duplicate_ivar_declaration);
13830  Diag(ClsIvar->getLocation(), diag::note_previous_definition);
13831  continue;
13832  }
13833  for (const auto *Ext : IDecl->known_extensions()) {
13834  if (const ObjCIvarDecl *ClsExtIvar
13835  = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
13836  Diag(ClsFields[i]->getLocation(),
13837  diag::err_duplicate_ivar_declaration);
13838  Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
13839  continue;
13840  }
13841  }
13842  }
13843  ClsFields[i]->setLexicalDeclContext(CDecl);
13844  CDecl->addDecl(ClsFields[i]);
13845  }
13846  CDecl->setIvarLBraceLoc(LBrac);
13847  CDecl->setIvarRBraceLoc(RBrac);
13848  }
13849  }
13850 
13851  if (Attr)
13852  ProcessDeclAttributeList(S, Record, Attr);
13853 }
13854 
13855 /// \brief Determine whether the given integral value is representable within
13856 /// the given type T.
13858  llvm::APSInt &Value,
13859  QualType T) {
13860  assert(T->isIntegralType(Context) && "Integral type required!");
13861  unsigned BitWidth = Context.getIntWidth(T);
13862 
13863  if (Value.isUnsigned() || Value.isNonNegative()) {
13865  --BitWidth;
13866  return Value.getActiveBits() <= BitWidth;
13867  }
13868  return Value.getMinSignedBits() <= BitWidth;
13869 }
13870 
13871 // \brief Given an integral type, return the next larger integral type
13872 // (or a NULL type of no such type exists).
13874  // FIXME: Int128/UInt128 support, which also needs to be introduced into
13875  // enum checking below.
13876  assert(T->isIntegralType(Context) && "Integral type required!");
13877  const unsigned NumTypes = 4;
13878  QualType SignedIntegralTypes[NumTypes] = {
13879  Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
13880  };
13881  QualType UnsignedIntegralTypes[NumTypes] = {
13882  Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
13883  Context.UnsignedLongLongTy
13884  };
13885 
13886  unsigned BitWidth = Context.getTypeSize(T);
13887  QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
13888  : UnsignedIntegralTypes;
13889  for (unsigned I = 0; I != NumTypes; ++I)
13890  if (Context.getTypeSize(Types[I]) > BitWidth)
13891  return Types[I];
13892 
13893  return QualType();
13894 }
13895 
13897  EnumConstantDecl *LastEnumConst,
13898  SourceLocation IdLoc,
13899  IdentifierInfo *Id,
13900  Expr *Val) {
13901  unsigned IntWidth = Context.getTargetInfo().getIntWidth();
13902  llvm::APSInt EnumVal(IntWidth);
13903  QualType EltTy;
13904 
13905  if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
13906  Val = nullptr;
13907 
13908  if (Val)
13909  Val = DefaultLvalueConversion(Val).get();
13910 
13911  if (Val) {
13912  if (Enum->isDependentType() || Val->isTypeDependent())
13913  EltTy = Context.DependentTy;
13914  else {
13915  SourceLocation ExpLoc;
13916  if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
13917  !getLangOpts().MSVCCompat) {
13918  // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
13919  // constant-expression in the enumerator-definition shall be a converted
13920  // constant expression of the underlying type.
13921  EltTy = Enum->getIntegerType();
13922  ExprResult Converted =
13923  CheckConvertedConstantExpression(Val, EltTy, EnumVal,
13924  CCEK_Enumerator);
13925  if (Converted.isInvalid())
13926  Val = nullptr;
13927  else
13928  Val = Converted.get();
13929  } else if (!Val->isValueDependent() &&
13930  !(Val = VerifyIntegerConstantExpression(Val,
13931  &EnumVal).get())) {
13932  // C99 6.7.2.2p2: Make sure we have an integer constant expression.
13933  } else {
13934  if (Enum->isFixed()) {
13935  EltTy = Enum->getIntegerType();
13936 
13937  // In Obj-C and Microsoft mode, require the enumeration value to be
13938  // representable in the underlying type of the enumeration. In C++11,
13939  // we perform a non-narrowing conversion as part of converted constant
13940  // expression checking.
13941  if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
13942  if (getLangOpts().MSVCCompat) {
13943  Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
13944  Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
13945  } else
13946  Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
13947  } else
13948  Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
13949  } else if (getLangOpts().CPlusPlus) {
13950  // C++11 [dcl.enum]p5:
13951  // If the underlying type is not fixed, the type of each enumerator
13952  // is the type of its initializing value:
13953  // - If an initializer is specified for an enumerator, the
13954  // initializing value has the same type as the expression.
13955  EltTy = Val->getType();
13956  } else {
13957  // C99 6.7.2.2p2:
13958  // The expression that defines the value of an enumeration constant
13959  // shall be an integer constant expression that has a value
13960  // representable as an int.
13961 
13962  // Complain if the value is not representable in an int.
13964  Diag(IdLoc, diag::ext_enum_value_not_int)
13965  << EnumVal.toString(10) << Val->getSourceRange()
13966  << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
13967  else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
13968  // Force the type of the expression to 'int'.
13969  Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
13970  }
13971  EltTy = Val->getType();
13972  }
13973  }
13974  }
13975  }
13976 
13977  if (!Val) {
13978  if (Enum->isDependentType())
13979  EltTy = Context.DependentTy;
13980  else if (!LastEnumConst) {
13981  // C++0x [dcl.enum]p5:
13982  // If the underlying type is not fixed, the type of each enumerator
13983  // is the type of its initializing value:
13984  // - If no initializer is specified for the first enumerator, the
13985  // initializing value has an unspecified integral type.
13986  //
13987  // GCC uses 'int' for its unspecified integral type, as does
13988  // C99 6.7.2.2p3.
13989  if (Enum->isFixed()) {
13990  EltTy = Enum->getIntegerType();
13991  }
13992  else {
13993  EltTy = Context.IntTy;
13994  }
13995  } else {
13996  // Assign the last value + 1.
13997  EnumVal = LastEnumConst->getInitVal();
13998  ++EnumVal;
13999  EltTy = LastEnumConst->getType();
14000 
14001  // Check for overflow on increment.
14002  if (EnumVal < LastEnumConst->getInitVal()) {
14003  // C++0x [dcl.enum]p5:
14004  // If the underlying type is not fixed, the type of each enumerator
14005  // is the type of its initializing value:
14006  //
14007  // - Otherwise the type of the initializing value is the same as
14008  // the type of the initializing value of the preceding enumerator
14009  // unless the incremented value is not representable in that type,
14010  // in which case the type is an unspecified integral type
14011  // sufficient to contain the incremented value. If no such type
14012  // exists, the program is ill-formed.
14014  if (T.isNull() || Enum->isFixed()) {
14015  // There is no integral type larger enough to represent this
14016  // value. Complain, then allow the value to wrap around.
14017  EnumVal = LastEnumConst->getInitVal();
14018  EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
14019  ++EnumVal;
14020  if (Enum->isFixed())
14021  // When the underlying type is fixed, this is ill-formed.
14022  Diag(IdLoc, diag::err_enumerator_wrapped)
14023  << EnumVal.toString(10)
14024  << EltTy;
14025  else
14026  Diag(IdLoc, diag::ext_enumerator_increment_too_large)
14027  << EnumVal.toString(10);
14028  } else {
14029  EltTy = T;
14030  }
14031 
14032  // Retrieve the last enumerator's value, extent that type to the
14033  // type that is supposed to be large enough to represent the incremented
14034  // value, then increment.
14035  EnumVal = LastEnumConst->getInitVal();
14036  EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
14037  EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
14038  ++EnumVal;
14039 
14040  // If we're not in C++, diagnose the overflow of enumerator values,
14041  // which in C99 means that the enumerator value is not representable in
14042  // an int (C99 6.7.2.2p2). However, we support GCC's extension that
14043  // permits enumerator values that are representable in some larger
14044  // integral type.
14045  if (!getLangOpts().CPlusPlus && !T.isNull())
14046  Diag(IdLoc, diag::warn_enum_value_overflow);
14047  } else if (!getLangOpts().CPlusPlus &&
14048  !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
14049  // Enforce C99 6.7.2.2p2 even when we compute the next value.
14050  Diag(IdLoc, diag::ext_enum_value_not_int)
14051  << EnumVal.toString(10) << 1;
14052  }
14053  }
14054  }
14055 
14056  if (!EltTy->isDependentType()) {
14057  // Make the enumerator value match the signedness and size of the
14058  // enumerator's type.
14059  EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
14060  EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
14061  }
14062 
14063  return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
14064  Val, EnumVal);
14065 }
14066 
14068  SourceLocation IILoc) {
14069  if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) ||
14071  return SkipBodyInfo();
14072 
14073  // We have an anonymous enum definition. Look up the first enumerator to
14074  // determine if we should merge the definition with an existing one and
14075  // skip the body.
14076  NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
14078  auto *PrevECD = dyn_cast_or_null<EnumConstantDecl>(PrevDecl);
14079  if (!PrevECD)
14080  return SkipBodyInfo();
14081 
14082  EnumDecl *PrevED = cast<EnumDecl>(PrevECD->getDeclContext());
14083  NamedDecl *Hidden;
14084  if (!PrevED->getDeclName() && !hasVisibleDefinition(PrevED, &Hidden)) {
14085  SkipBodyInfo Skip;
14086  Skip.Previous = Hidden;
14087  return Skip;
14088  }
14089 
14090  return SkipBodyInfo();
14091 }
14092 
14093 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
14094  SourceLocation IdLoc, IdentifierInfo *Id,
14096  SourceLocation EqualLoc, Expr *Val) {
14097  EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
14098  EnumConstantDecl *LastEnumConst =
14099  cast_or_null<EnumConstantDecl>(lastEnumConst);
14100 
14101  // The scope passed in may not be a decl scope. Zip up the scope tree until
14102  // we find one that is.
14103  S = getNonFieldDeclScope(S);
14104 
14105  // Verify that there isn't already something declared with this name in this
14106  // scope.
14107  NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
14109  if (PrevDecl && PrevDecl->isTemplateParameter()) {
14110  // Maybe we will complain about the shadowed template parameter.
14111  DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
14112  // Just pretend that we didn't see the previous declaration.
14113  PrevDecl = nullptr;
14114  }
14115 
14116  // C++ [class.mem]p15:
14117  // If T is the name of a class, then each of the following shall have a name
14118  // different from T:
14119  // - every enumerator of every member of class T that is an unscoped
14120  // enumerated type
14121  if (!TheEnumDecl->isScoped())
14122  DiagnoseClassNameShadow(TheEnumDecl->getDeclContext(),
14123  DeclarationNameInfo(Id, IdLoc));
14124 
14125  EnumConstantDecl *New =
14126  CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
14127  if (!New)
14128  return nullptr;
14129 
14130  if (PrevDecl) {
14131  // When in C++, we may get a TagDecl with the same name; in this case the
14132  // enum constant will 'hide' the tag.
14133  assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
14134  "Received TagDecl when not in C++!");
14135  if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S) &&
14136  shouldLinkPossiblyHiddenDecl(PrevDecl, New)) {
14137  if (isa<EnumConstantDecl>(PrevDecl))
14138  Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
14139  else
14140  Diag(IdLoc, diag::err_redefinition) << Id;
14141  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
14142  return nullptr;
14143  }
14144  }
14145 
14146  // Process attributes.
14147  if (Attr) ProcessDeclAttributeList(S, New, Attr);
14148 
14149  // Register this decl in the current scope stack.
14150  New->setAccess(TheEnumDecl->getAccess());
14151  PushOnScopeChains(New, S);
14152 
14153  ActOnDocumentableDecl(New);
14154 
14155  return New;
14156 }
14157 
14158 // Returns true when the enum initial expression does not trigger the
14159 // duplicate enum warning. A few common cases are exempted as follows:
14160 // Element2 = Element1
14161 // Element2 = Element1 + 1
14162 // Element2 = Element1 - 1
14163 // Where Element2 and Element1 are from the same enum.
14165  Expr *InitExpr = ECD->getInitExpr();
14166  if (!InitExpr)
14167  return true;
14168  InitExpr = InitExpr->IgnoreImpCasts();
14169 
14170  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
14171  if (!BO->isAdditiveOp())
14172  return true;
14173  IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
14174  if (!IL)
14175  return true;
14176  if (IL->getValue() != 1)
14177  return true;
14178 
14179  InitExpr = BO->getLHS();
14180  }
14181 
14182  // This checks if the elements are from the same enum.
14183  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
14184  if (!DRE)
14185  return true;
14186 
14187  EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
14188  if (!EnumConstant)
14189  return true;
14190 
14191  if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
14192  Enum)
14193  return true;
14194 
14195  return false;
14196 }
14197 
14198 namespace {
14199 struct DupKey {
14200  int64_t val;
14201  bool isTombstoneOrEmptyKey;
14202  DupKey(int64_t val, bool isTombstoneOrEmptyKey)
14203  : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
14204 };
14205 
14206 static DupKey GetDupKey(const llvm::APSInt& Val) {
14207  return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
14208  false);
14209 }
14210 
14211 struct DenseMapInfoDupKey {
14212  static DupKey getEmptyKey() { return DupKey(0, true); }
14213  static DupKey getTombstoneKey() { return DupKey(1, true); }
14214  static unsigned getHashValue(const DupKey Key) {
14215  return (unsigned)(Key.val * 37);
14216  }
14217  static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
14218  return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
14219  LHS.val == RHS.val;
14220  }
14221 };
14222 } // end anonymous namespace
14223 
14224 // Emits a warning when an element is implicitly set a value that
14225 // a previous element has already been set to.
14227  EnumDecl *Enum,
14228  QualType EnumType) {
14229  if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
14230  return;
14231  // Avoid anonymous enums
14232  if (!Enum->getIdentifier())
14233  return;
14234 
14235  // Only check for small enums.
14236  if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
14237  return;
14238 
14239  typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
14240  typedef SmallVector<ECDVector *, 3> DuplicatesVector;
14241 
14242  typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
14243  typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
14244  ValueToVectorMap;
14245 
14246  DuplicatesVector DupVector;
14247  ValueToVectorMap EnumMap;
14248 
14249  // Populate the EnumMap with all values represented by enum constants without
14250  // an initialier.
14251  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14252  EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
14253 
14254  // Null EnumConstantDecl means a previous diagnostic has been emitted for
14255  // this constant. Skip this enum since it may be ill-formed.
14256  if (!ECD) {
14257  return;
14258  }
14259 
14260  if (ECD->getInitExpr())
14261  continue;
14262 
14263  DupKey Key = GetDupKey(ECD->getInitVal());
14264  DeclOrVector &Entry = EnumMap[Key];
14265 
14266  // First time encountering this value.
14267  if (Entry.isNull())
14268  Entry = ECD;
14269  }
14270 
14271  // Create vectors for any values that has duplicates.
14272  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14273  EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
14274  if (!ValidDuplicateEnum(ECD, Enum))
14275  continue;
14276 
14277  DupKey Key = GetDupKey(ECD->getInitVal());
14278 
14279  DeclOrVector& Entry = EnumMap[Key];
14280  if (Entry.isNull())
14281  continue;
14282 
14283  if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
14284  // Ensure constants are different.
14285  if (D == ECD)
14286  continue;
14287 
14288  // Create new vector and push values onto it.
14289  ECDVector *Vec = new ECDVector();
14290  Vec->push_back(D);
14291  Vec->push_back(ECD);
14292 
14293  // Update entry to point to the duplicates vector.
14294  Entry = Vec;
14295 
14296  // Store the vector somewhere we can consult later for quick emission of
14297  // diagnostics.
14298  DupVector.push_back(Vec);
14299  continue;
14300  }
14301 
14302  ECDVector *Vec = Entry.get<ECDVector*>();
14303  // Make sure constants are not added more than once.
14304  if (*Vec->begin() == ECD)
14305  continue;
14306 
14307  Vec->push_back(ECD);
14308  }
14309 
14310  // Emit diagnostics.
14311  for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
14312  DupVectorEnd = DupVector.end();
14313  DupVectorIter != DupVectorEnd; ++DupVectorIter) {
14314  ECDVector *Vec = *DupVectorIter;
14315  assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
14316 
14317  // Emit warning for one enum constant.
14318  ECDVector::iterator I = Vec->begin();
14319  S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
14320  << (*I)->getName() << (*I)->getInitVal().toString(10)
14321  << (*I)->getSourceRange();
14322  ++I;
14323 
14324  // Emit one note for each of the remaining enum constants with
14325  // the same value.
14326  for (ECDVector::iterator E = Vec->end(); I != E; ++I)
14327  S.Diag((*I)->getLocation(), diag::note_duplicate_element)
14328  << (*I)->getName() << (*I)->getInitVal().toString(10)
14329  << (*I)->getSourceRange();
14330  delete Vec;
14331  }
14332 }
14333 
14334 bool Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
14335  bool AllowMask) const {
14336  assert(ED->hasAttr<FlagEnumAttr>() && "looking for value in non-flag enum");
14337  assert(ED->isCompleteDefinition() && "expected enum definition");
14338 
14339  auto R = FlagBitsCache.insert(std::make_pair(ED, llvm::APInt()));
14340  llvm::APInt &FlagBits = R.first->second;
14341 
14342  if (R.second) {
14343  for (auto *E : ED->enumerators()) {
14344  const auto &EVal = E->getInitVal();
14345  // Only single-bit enumerators introduce new flag values.
14346  if (EVal.isPowerOf2())
14347  FlagBits = FlagBits.zextOrSelf(EVal.getBitWidth()) | EVal;
14348  }
14349  }
14350 
14351  // A value is in a flag enum if either its bits are a subset of the enum's
14352  // flag bits (the first condition) or we are allowing masks and the same is
14353  // true of its complement (the second condition). When masks are allowed, we
14354  // allow the common idiom of ~(enum1 | enum2) to be a valid enum value.
14355  //
14356  // While it's true that any value could be used as a mask, the assumption is
14357  // that a mask will have all of the insignificant bits set. Anything else is
14358  // likely a logic error.
14359  llvm::APInt FlagMask = ~FlagBits.zextOrTrunc(Val.getBitWidth());
14360  return !(FlagMask & Val) || (AllowMask && !(FlagMask & ~Val));
14361 }
14362 
14364  SourceLocation RBraceLoc, Decl *EnumDeclX,
14365  ArrayRef<Decl *> Elements,
14366  Scope *S, AttributeList *Attr) {
14367  EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
14369 
14370  if (Attr)
14371  ProcessDeclAttributeList(S, Enum, Attr);
14372 
14373  if (Enum->isDependentType()) {
14374  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14375  EnumConstantDecl *ECD =
14376  cast_or_null<EnumConstantDecl>(Elements[i]);
14377  if (!ECD) continue;
14378 
14379  ECD->setType(EnumType);
14380  }
14381 
14383  return;
14384  }
14385 
14386  // TODO: If the result value doesn't fit in an int, it must be a long or long
14387  // long value. ISO C does not support this, but GCC does as an extension,
14388  // emit a warning.
14389  unsigned IntWidth = Context.getTargetInfo().getIntWidth();
14390  unsigned CharWidth = Context.getTargetInfo().getCharWidth();
14391  unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
14392 
14393  // Verify that all the values are okay, compute the size of the values, and
14394  // reverse the list.
14395  unsigned NumNegativeBits = 0;
14396  unsigned NumPositiveBits = 0;
14397 
14398  // Keep track of whether all elements have type int.
14399  bool AllElementsInt = true;
14400 
14401  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
14402  EnumConstantDecl *ECD =
14403  cast_or_null<EnumConstantDecl>(Elements[i]);
14404  if (!ECD) continue; // Already issued a diagnostic.
14405 
14406  const llvm::APSInt &InitVal = ECD->getInitVal();
14407 
14408  // Keep track of the size of positive and negative values.
14409  if (InitVal.isUnsigned() || InitVal.isNonNegative())
14410  NumPositiveBits = std::max(NumPositiveBits,
14411  (unsigned)InitVal.getActiveBits());
14412  else
14413  NumNegativeBits = std::max(NumNegativeBits,
14414  (unsigned)InitVal.getMinSignedBits());
14415 
14416  // Keep track of whether every enum element has type int (very commmon).
14417  if (AllElementsInt)
14418  AllElementsInt = ECD->getType() == Context.IntTy;
14419  }
14420 
14421  // Figure out the type that should be used for this enum.
14422  QualType BestType;
14423  unsigned BestWidth;
14424 
14425  // C++0x N3000 [conv.prom]p3:
14426  // An rvalue of an unscoped enumeration type whose underlying
14427  // type is not fixed can be converted to an rvalue of the first
14428  // of the following types that can represent all the values of
14429  // the enumeration: int, unsigned int, long int, unsigned long
14430  // int, long long int, or unsigned long long int.
14431  // C99 6.4.4.3p2:
14432  // An identifier declared as an enumeration constant has type int.
14433  // The C99 rule is modified by a gcc extension
14434  QualType BestPromotionType;
14435 
14436  bool Packed = Enum->hasAttr<PackedAttr>();
14437  // -fshort-enums is the equivalent to specifying the packed attribute on all
14438  // enum definitions.
14439  if (LangOpts.ShortEnums)
14440  Packed = true;
14441 
14442  if (Enum->isFixed()) {
14443  BestType = Enum->getIntegerType();
14444  if (BestType->isPromotableIntegerType())
14445  BestPromotionType = Context.getPromotedIntegerType(BestType);
14446  else
14447  BestPromotionType = BestType;
14448 
14449  BestWidth = Context.getIntWidth(BestType);
14450  }
14451  else if (NumNegativeBits) {
14452  // If there is a negative value, figure out the smallest integer type (of
14453  // int/long/longlong) that fits.
14454  // If it's packed, check also if it fits a char or a short.
14455  if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
14456  BestType = Context.SignedCharTy;
14457  BestWidth = CharWidth;
14458  } else if (Packed && NumNegativeBits <= ShortWidth &&
14459  NumPositiveBits < ShortWidth) {
14460  BestType = Context.ShortTy;
14461  BestWidth = ShortWidth;
14462  } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
14463  BestType = Context.IntTy;
14464  BestWidth = IntWidth;
14465  } else {
14466  BestWidth = Context.getTargetInfo().getLongWidth();
14467 
14468  if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
14469  BestType = Context.LongTy;
14470  } else {
14471  BestWidth = Context.getTargetInfo().getLongLongWidth();
14472 
14473  if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
14474  Diag(Enum->getLocation(), diag::ext_enum_too_large);
14475  BestType = Context.LongLongTy;
14476  }
14477  }
14478  BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
14479  } else {
14480  // If there is no negative value, figure out the smallest type that fits
14481  // all of the enumerator values.
14482  // If it's packed, check also if it fits a char or a short.
14483  if (Packed && NumPositiveBits <= CharWidth) {
14484  BestType = Context.UnsignedCharTy;
14485  BestPromotionType = Context.IntTy;
14486  BestWidth = CharWidth;
14487  } else if (Packed && NumPositiveBits <= ShortWidth) {
14488  BestType = Context.UnsignedShortTy;
14489  BestPromotionType = Context.IntTy;
14490  BestWidth = ShortWidth;
14491  } else if (NumPositiveBits <= IntWidth) {
14492  BestType = Context.UnsignedIntTy;
14493  BestWidth = IntWidth;
14494  BestPromotionType
14495  = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
14497  } else if (NumPositiveBits <=
14498  (BestWidth = Context.getTargetInfo().getLongWidth())) {
14499  BestType = Context.UnsignedLongTy;
14500  BestPromotionType
14501  = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
14503  } else {
14504  BestWidth = Context.getTargetInfo().getLongLongWidth();
14505  assert(NumPositiveBits <= BestWidth &&
14506  "How could an initializer get larger than ULL?");
14507  BestType = Context.UnsignedLongLongTy;
14508  BestPromotionType
14509  = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
14511  }
14512  }
14513 
14514  // Loop over all of the enumerator constants, changing their types to match
14515  // the type of the enum if needed.
14516  for (auto *D : Elements) {
14517  auto *ECD = cast_or_null<EnumConstantDecl>(D);
14518  if (!ECD) continue; // Already issued a diagnostic.
14519 
14520  // Standard C says the enumerators have int type, but we allow, as an
14521  // extension, the enumerators to be larger than int size. If each
14522  // enumerator value fits in an int, type it as an int, otherwise type it the
14523  // same as the enumerator decl itself. This means that in "enum { X = 1U }"
14524  // that X has type 'int', not 'unsigned'.
14525 
14526  // Determine whether the value fits into an int.
14527  llvm::APSInt InitVal = ECD->getInitVal();
14528 
14529  // If it fits into an integer type, force it. Otherwise force it to match
14530  // the enum decl type.
14531  QualType NewTy;
14532  unsigned NewWidth;
14533  bool NewSign;
14534  if (!getLangOpts().CPlusPlus &&
14535  !Enum->isFixed() &&
14537  NewTy = Context.IntTy;
14538  NewWidth = IntWidth;
14539  NewSign = true;
14540  } else if (ECD->getType() == BestType) {
14541  // Already the right type!
14542  if (getLangOpts().CPlusPlus)
14543  // C++ [dcl.enum]p4: Following the closing brace of an
14544  // enum-specifier, each enumerator has the type of its
14545  // enumeration.
14546  ECD->setType(EnumType);
14547  continue;
14548  } else {
14549  NewTy = BestType;
14550  NewWidth = BestWidth;
14551  NewSign = BestType->isSignedIntegerOrEnumerationType();
14552  }
14553 
14554  // Adjust the APSInt value.
14555  InitVal = InitVal.extOrTrunc(NewWidth);
14556  InitVal.setIsSigned(NewSign);
14557  ECD->setInitVal(InitVal);
14558 
14559  // Adjust the Expr initializer and type.
14560  if (ECD->getInitExpr() &&
14561  !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
14562  ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
14564  ECD->getInitExpr(),
14565  /*base paths*/ nullptr,
14566  VK_RValue));
14567  if (getLangOpts().CPlusPlus)
14568  // C++ [dcl.enum]p4: Following the closing brace of an
14569  // enum-specifier, each enumerator has the type of its
14570  // enumeration.
14571  ECD->setType(EnumType);
14572  else
14573  ECD->setType(NewTy);
14574  }
14575 
14576  Enum->completeDefinition(BestType, BestPromotionType,
14577  NumPositiveBits, NumNegativeBits);
14578 
14579  CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
14580 
14581  if (Enum->hasAttr<FlagEnumAttr>()) {
14582  for (Decl *D : Elements) {
14583  EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D);
14584  if (!ECD) continue; // Already issued a diagnostic.
14585 
14586  llvm::APSInt InitVal = ECD->getInitVal();
14587  if (InitVal != 0 && !InitVal.isPowerOf2() &&
14588  !IsValueInFlagEnum(Enum, InitVal, true))
14589  Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range)
14590  << ECD << Enum;
14591  }
14592  }
14593 
14594  // Now that the enum type is defined, ensure it's not been underaligned.
14595  if (Enum->hasAttrs())
14597 }
14598 
14600  SourceLocation StartLoc,
14601  SourceLocation EndLoc) {
14602  StringLiteral *AsmString = cast<StringLiteral>(expr);
14603 
14605  AsmString, StartLoc,
14606  EndLoc);
14607  CurContext->addDecl(New);
14608  return New;
14609 }
14610 
14612  SourceLocation ImportLoc, DeclContext *DC,
14613  bool FromInclude = false) {
14614  SourceLocation ExternCLoc;
14615 
14616  if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
14617  switch (LSD->getLanguage()) {
14619  if (ExternCLoc.isInvalid())
14620  ExternCLoc = LSD->getLocStart();
14621  break;
14623  break;
14624  }
14625  DC = LSD->getParent();
14626  }
14627 
14628  while (isa<LinkageSpecDecl>(DC))
14629  DC = DC->getParent();
14630 
14631  if (!isa<TranslationUnitDecl>(DC)) {
14632  S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))
14633  ? diag::ext_module_import_not_at_top_level_noop
14634  : diag::err_module_import_not_at_top_level_fatal)
14635  << M->getFullModuleName() << DC;
14636  S.Diag(cast<Decl>(DC)->getLocStart(),
14637  diag::note_module_import_not_at_top_level) << DC;
14638  } else if (!M->IsExternC && ExternCLoc.isValid()) {
14639  S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)
14640  << M->getFullModuleName();
14641  S.Diag(ExternCLoc, diag::note_module_import_in_extern_c);
14642  }
14643 }
14644 
14646  return checkModuleImportContext(*this, M, ImportLoc, CurContext);
14647 }
14648 
14650  SourceLocation ImportLoc,
14651  ModuleIdPath Path) {
14652  Module *Mod =
14653  getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
14654  /*IsIncludeDirective=*/false);
14655  if (!Mod)
14656  return true;
14657 
14658  VisibleModules.setVisible(Mod, ImportLoc);
14659 
14660  checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
14661 
14662  // FIXME: we should support importing a submodule within a different submodule
14663  // of the same top-level module. Until we do, make it an error rather than
14664  // silently ignoring the import.
14666  Diag(ImportLoc, diag::err_module_self_import)
14669  Diag(ImportLoc, diag::err_module_import_in_implementation)
14671 
14672  SmallVector<SourceLocation, 2> IdentifierLocs;
14673  Module *ModCheck = Mod;
14674  for (unsigned I = 0, N = Path.size(); I != N; ++I) {
14675  // If we've run out of module parents, just drop the remaining identifiers.
14676  // We need the length to be consistent.
14677  if (!ModCheck)
14678  break;
14679  ModCheck = ModCheck->Parent;
14680 
14681  IdentifierLocs.push_back(Path[I].second);
14682  }
14683 
14686  AtLoc.isValid()? AtLoc : ImportLoc,
14687  Mod, IdentifierLocs);
14689  return Import;
14690 }
14691 
14693  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
14694 
14695  // Determine whether we're in the #include buffer for a module. The #includes
14696  // in that buffer do not qualify as module imports; they're just an
14697  // implementation detail of us building the module.
14698  //
14699  // FIXME: Should we even get ActOnModuleInclude calls for those?
14700  bool IsInModuleIncludes =
14701  TUKind == TU_Module &&
14702  getSourceManager().isWrittenInMainFile(DirectiveLoc);
14703 
14704  // If this module import was due to an inclusion directive, create an
14705  // implicit import declaration to capture it in the AST.
14706  if (!IsInModuleIncludes) {
14709  DirectiveLoc, Mod,
14710  DirectiveLoc);
14711  TU->addDecl(ImportD);
14713  }
14714 
14716  VisibleModules.setVisible(Mod, DirectiveLoc);
14717 }
14718 
14720  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14721 
14722  if (getLangOpts().ModulesLocalVisibility)
14723  VisibleModulesStack.push_back(std::move(VisibleModules));
14724  VisibleModules.setVisible(Mod, DirectiveLoc);
14725 }
14726 
14727 void Sema::ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod) {
14728  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
14729 
14730  if (getLangOpts().ModulesLocalVisibility) {
14731  VisibleModules = std::move(VisibleModulesStack.back());
14732  VisibleModulesStack.pop_back();
14733  VisibleModules.setVisible(Mod, DirectiveLoc);
14734  }
14735 }
14736 
14738  Module *Mod) {
14739  // Bail if we're not allowed to implicitly import a module here.
14740  if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery)
14741  return;
14742 
14743  // Create the implicit import declaration.
14746  Loc, Mod, Loc);
14747  TU->addDecl(ImportD);
14749 
14750  // Make the module visible.
14752  VisibleModules.setVisible(Mod, Loc);
14753 }
14754 
14756  IdentifierInfo* AliasName,
14757  SourceLocation PragmaLoc,
14758  SourceLocation NameLoc,
14759  SourceLocation AliasNameLoc) {
14760  NamedDecl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
14762  AsmLabelAttr *Attr =
14763  AsmLabelAttr::CreateImplicit(Context, AliasName->getName(), AliasNameLoc);
14764 
14765  // If a declaration that:
14766  // 1) declares a function or a variable
14767  // 2) has external linkage
14768  // already exists, add a label attribute to it.
14769  if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
14770  if (isDeclExternC(PrevDecl))
14771  PrevDecl->addAttr(Attr);
14772  else
14773  Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
14774  << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
14775  // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
14776  } else
14777  (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
14778 }
14779 
14781  SourceLocation PragmaLoc,
14782  SourceLocation NameLoc) {
14783  Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
14784 
14785  if (PrevDecl) {
14786  PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
14787  } else {
14788  (void)WeakUndeclaredIdentifiers.insert(
14789  std::pair<IdentifierInfo*,WeakInfo>
14790  (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
14791  }
14792 }
14793 
14795  IdentifierInfo* AliasName,
14796  SourceLocation PragmaLoc,
14797  SourceLocation NameLoc,
14798  SourceLocation AliasNameLoc) {
14799  Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
14801  WeakInfo W = WeakInfo(Name, NameLoc);
14802 
14803  if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
14804  if (!PrevDecl->hasAttr<AliasAttr>())
14805  if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
14806  DeclApplyPragmaWeak(TUScope, ND, W);
14807  } else {
14808  (void)WeakUndeclaredIdentifiers.insert(
14809  std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
14810  }
14811 }
14812 
14814  return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
14815 }
14816 
14818  const Decl *D = cast_or_null<Decl>(getCurObjCLexicalContext());
14819  if (!D)
14820  return AR_Available;
14821 
14822  // If we are within an Objective-C method, we should consult
14823  // both the availability of the method as well as the
14824  // enclosing class. If the class is (say) deprecated,
14825  // the entire method is considered deprecated from the
14826  // purpose of checking if the current context is deprecated.
14827  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
14829  if (R != AR_Available)
14830  return R;
14831  D = MD->getClassInterface();
14832  }
14833  // If we are within an Objective-c @implementation, it
14834  // gets the same availability context as the @interface.
14835  else if (const ObjCImplementationDecl *ID =
14836  dyn_cast<ObjCImplementationDecl>(D)) {
14837  D = ID->getClassInterface();
14838  }
14839  // Recover from user error.
14840  return D ? D->getAvailability() : AR_Available;
14841 }
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossibleZeroParamPrototype)
Definition: SemaDecl.cpp:10693
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:265
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:207
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5204
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:451
param_const_iterator param_begin() const
Definition: DeclObjC.h:359
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2393
void setHasSkippedBody(bool Skipped=true)
Definition: Decl.h:1888
Defines the clang::ASTContext interface.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
Definition: SemaDecl.cpp:2575
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1332
SourceLocation getEnd() const
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
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:2658
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:971
CanQualType LongLongTy
Definition: ASTContext.h:889
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void setImplicit(bool I=true)
Definition: DeclBase.h:515
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:2534
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:4944
CK_LValueToRValue - A conversion which causes the extraction of an r-value from the operand gl-value...
void setDeclsInPrototypeScope(ArrayRef< NamedDecl * > NewDecls)
Definition: Decl.cpp:2760
bool isVariadic() const
Definition: Type.h:3255
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:1192
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
Definition: ScopeInfo.h:646
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2076
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:916
iterator begin() const
Definition: DeclBase.h:1090
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:1807
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:169
bool CheckNontrivialField(FieldDecl *FD)
Definition: SemaDecl.cpp:13219
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
Definition: ASTContext.h:1488
no exception specification
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
Definition: DeclTemplate.h:938
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
Definition: Type.h:5627
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:3234
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2147
EvaluatedExprVisitor - This class visits 'Expr *'s.
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:536
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:2140
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:2262
A (possibly-)qualified type.
Definition: Type.h:575
ASTConsumer & Consumer
Definition: Sema.h:296
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:13294
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1378
Simple class containing the result of Sema::CorrectTypo.
capture_const_range captures() const
Definition: DeclCXX.h:1070
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any...
Definition: Decl.cpp:3018
void InstantiatedLocal(const Decl *D, Decl *Inst)
base_class_range bases()
Definition: DeclCXX.h:713
bool isInvalid() const
Definition: Ownership.h:159
const AttributeList * getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1454
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:535
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Definition: SemaDecl.cpp:14794
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, SmallVectorImpl< NamedDecl * > &Chaining, bool MSAnonStruct)
InjectAnonymousStructOrUnionMembers - Inject the members of the anonymous struct or union AnonRecord ...
Definition: SemaDecl.cpp:3995
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2199
bool isReplaceableGlobalAllocationFunction() const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2584
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:563
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:2954
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:2277
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1077
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1263
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1003
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
Definition: SemaDecl.cpp:5218
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
Definition: Decl.h:313
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:252
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1218
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:948
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
Definition: DeclBase.h:613
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2636
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:549
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:164
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:1881
Decl * getRepAsDecl() const
Definition: DeclSpec.h:485
void setAttrs(const AttrVec &Attrs)
Definition: DeclBase.h:440
const LangOptions & getLangOpts() const
Definition: Sema.h:1041
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Sema/Lookup.h:209
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:220
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef< Decl * > Elements, EnumDecl *Enum, QualType EnumType)
Definition: SemaDecl.cpp:14226
ArrayRef< RawComment * > getComments() const
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition: Type.cpp:3668
DeclClass * getAsSingle() const
Definition: Sema/Lookup.h:448
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:921
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Sema/Lookup.h:465
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:3116
Filter makeFilter()
Create a filter for this result set.
Definition: Sema/Lookup.h:622
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:935
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1439
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:2213
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:3748
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2847
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:2526
const Expr * getInitExpr() const
Definition: Decl.h:2414
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
Definition: Sema.h:2098
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function...
Definition: Decl.cpp:3318
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:2397
unsigned getIntWidth(QualType T) const
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:511
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:3529
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:215
TypedefDecl - Represents the declaration of a typedef-name via the 'typedef' type specifier...
Definition: Decl.h:2598
Defines the SourceManager interface.
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
Definition: ASTContext.h:1425
void ActOnDocumentableDecls(ArrayRef< Decl * > Group)
Definition: SemaDecl.cpp:10355
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
Definition: SemaDecl.cpp:10351
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:1512
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:1352
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:171
A conversion function name, e.g., operator int.
Definition: DeclSpec.h:887
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsExplicitSpecialization)
Perform semantic checking of a new function declaration.
Definition: SemaDecl.cpp:8323
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:10984
void erase()
Erase the last element returned from this iterator.
Definition: Sema/Lookup.h:594
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
bool isRecordType() const
Definition: Type.h:5362
static const TST TST_typeofExpr
Definition: DeclSpec.h:294
QualType getUnderlyingType() const
Definition: Decl.h:2566
const DeclContext * getParentFunctionOrMethod() const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext...
Definition: DeclBase.cpp:199
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1118
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1675
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:98
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:132
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:2002
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function...
Definition: SemaDecl.cpp:5155
static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error)
Definition: SemaDecl.cpp:1709
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:125
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2149
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1589
Defines the C++ template declaration subclasses.
void setModulePrivate(bool MP=true)
Specify whether this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:570
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...
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:1269
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:680
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:3918
static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions &LangOpts)
canRedefineFunction - checks if a function can be redefined.
Definition: SemaDecl.cpp:2567
void setPure(bool P=true)
Definition: Decl.cpp:2513
bool hasFlexibleArrayMember() const
Definition: Decl.h:3218
void setPreviousDeclaration(FunctionDecl *PrevDecl)
Definition: Decl.cpp:2668
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
Not a friend object.
Definition: DeclBase.h:969
SCS getStorageClassSpec() const
Definition: DeclSpec.h:441
void AddDecl(Decl *D)
Definition: Scope.h:272
bool hasDefinition() const
Definition: DeclCXX.h:680
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition: DeclSpec.h:2223
PtrTy get() const
Definition: Ownership.h:163
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
Definition: Type.cpp:3118
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:6846
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:1249
bool isInStdNamespace() const
Definition: DeclBase.cpp:292
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:884
CanQualType LongTy
Definition: ASTContext.h:889
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition: Decl.cpp:3604
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2100
iterator begin() const
Definition: Sema/Lookup.h:276
unsigned getLength() const
Efficiently return the length of this identifier info.
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New)
Definition: SemaDecl.cpp:2583
static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc)
Definition: SemaDecl.cpp:4095
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:1091
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:1791
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2424
Declaration of a variable template.
const Expr * getInit() const
Definition: Decl.h:1070
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:402
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition: Sema.h:2679
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1149
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:444
virtual void completeDefinition()
completeDefinition - Notes that the definition of this type is now complete.
Definition: Decl.cpp:3755
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1356
decl_iterator begin()
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:555
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:90
bool isBooleanType() const
Definition: Type.h:5609
void ActOnExitFunctionContext()
Definition: SemaDecl.cpp:1172
A container of type source information.
Definition: Decl.h:61
Wrapper for void* pointer.
Definition: Ownership.h:45
Look up of a name that precedes the '::' scope resolution operator in C++.
Definition: Sema.h:2652
static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC)
Definition: SemaDecl.cpp:459
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3070
unsigned getFunctionPrototypeDepth() const
Returns the number of function prototype scopes in this scope chain.
Definition: Scope.h:255
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
Definition: Decl.cpp:3641
bool isBlockPointerType() const
Definition: Type.h:5311
static unsigned GetDiagnosticTypeSpecifierID(DeclSpec::TST T)
Definition: SemaDecl.cpp:3687
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
Definition: DeclSpec.h:1960
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:380
void PopDeclContext()
Definition: SemaDecl.cpp:1076
void setInitStyle(InitializationStyle Style)
Definition: Decl.h:1115
bool isConceptSpecified() const
Definition: DeclSpec.h:701
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:2134
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
Definition: SemaDecl.cpp:6697
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:1532
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
***static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc)
Definition: SemaDecl.cpp:11764
const TemplateArgumentLoc * getArgumentArray() const
Definition: TemplateBase.h:541
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group, bool TypeMayContainAuto=true)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Definition: SemaDecl.cpp:10303
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:80
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:4671
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:50
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:537
void ActOnObjCReenterContainerContext(DeclContext *DC)
Definition: SemaDecl.cpp:12809
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:9238
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:2096
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:699
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
CK_IntegralCast - A cast between integral types (other than to boolean).
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:1727
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:1940
bool isFileVarDecl() const
isFileVarDecl - Returns true for file scoped variable declaration.
Definition: Decl.h:1044
static const TST TST_underlyingType
Definition: DeclSpec.h:297
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:1608
DiagnosticsEngine & Diags
Definition: Sema.h:297
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
const Expr * getCallee() const
Definition: Expr.h:2170
TLSKind getTLSKind() const
Definition: Decl.cpp:1818
The "union" keyword.
Definition: Type.h:4180
Extra information about a function prototype.
Definition: Type.h:3067
AccessSpecifier getAccess() const
Definition: DeclBase.h:428
bool isCanonical() const
Definition: Type.h:5133
AutoTypeKeyword getKeyword() const
Definition: Type.h:3936
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1615
field_iterator field_begin() const
Definition: Decl.cpp:3746
bool isCLike() const
True if this class is C-like, without C++-specific features, e.g.
Definition: DeclCXX.cpp:969
The "__interface" keyword.
Definition: Type.h:4178
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1793
void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context)
Definition: SemaDecl.cpp:1097
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:319
void ActOnObjCTemporaryExitContainerContext(DeclContext *DC)
Invoked when we must temporarily exit the objective-c container scope for parsing/looking-up C constr...
Definition: SemaDecl.cpp:12803
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:926
static const TST TST_interface
Definition: DeclSpec.h:290
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:6780
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:48
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:4246
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:285
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:3265
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:35
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
Definition: SemaDecl.cpp:7377
bool isImageType() const
Definition: Type.h:5492
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
Definition: SemaDecl.cpp:10398
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:11019
bool isSingleTagDecl() const
Asks if the result is a single tag decl.
Definition: Sema/Lookup.h:471
static QualType getCoreType(QualType Ty)
Definition: SemaDecl.cpp:4531
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2847
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1553
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:1185
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1739
bool isVoidType() const
Definition: Type.h:5546
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
Definition: SemaDecl.cpp:3643
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:2826
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:5117
void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto)
Definition: SemaDecl.cpp:9663
Information about a template-id annotation token.
PipeType - OpenCL20.
Definition: Type.h:5020
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:12936
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:276
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:2755
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:10677
unsigned getNumParams() const
Definition: Type.h:3160
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3166
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:2460
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2073
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2629
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:942
DeclarationName getName() const
getName - Returns the embedded declaration name.
bool isConst() const
Definition: DeclCXX.h:1742
One of these records is kept for each identifier that is lexed.
iterator end() const
Definition: Sema/Lookup.h:277
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:3063
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:6873
ExtInfo withProducesResult(bool producesResult) const
Definition: Type.h:2941
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:5581
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:1429
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
Definition: Builtins.h:187
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:5555
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:4432
method_iterator end_overridden_methods() const
Definition: DeclCXX.cpp:1588
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3175
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:5137
static bool isDeclExternC(const Decl *D)
Returns true if given declaration has external C language linkage.
Definition: SemaDecl.cpp:5687
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
Definition: Ownership.h:233
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:3255
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:1526
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:4381
bool hasAttr() const
Definition: DeclBase.h:498
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:4068
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:929
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:3708
IdentifierInfo * getCorrectionAsIdentifierInfo() const
AttributeList * getList() const
void setManglingNumber(const NamedDecl *ND, unsigned Number)
Expr * getSizeExpr() const
Definition: Type.h:2591
static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S)
Definition: SemaDecl.cpp:2485
static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization)
Definition: SemaDecl.cpp:5459
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1766
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:91
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:1966
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1054
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3165
bool decl_empty() const
Definition: Scope.h:270
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e...
Definition: SemaDecl.cpp:12709
Missing a type from <ucontext.h>
Definition: ASTContext.h:1740
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
Definition: SemaDecl.cpp:11583
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:1213
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1727
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:1696
bool isReferenceType() const
Definition: Type.h:5314
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:685
static const TST TST_class
Definition: DeclSpec.h:291
QualType getReturnType() const
Definition: Decl.h:1956
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:11665
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:2209
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:891
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2788
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:53
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:904
void removeConst()
Definition: Type.h:233
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:353
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition: Decl.h:452
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:1748
static bool isIncrementDecrementOp(Opcode Op)
Definition: Expr.h:1715
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:259
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3538
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:925
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:1769
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:675
bool isTranslationUnit() const
Definition: DeclBase.h:1269
bool isNoreturnSpecified() const
Definition: DeclSpec.h:565
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1788
TagKind getTagKind() const
Definition: Decl.h:2847
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:1217
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1962
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:374
static const TST TST_error
Definition: DeclSpec.h:302
Token - This structure provides full information about a lexed token.
Definition: Token.h:37
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:14067
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
Definition: DeclCXX.h:1107
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:999
static const TST TST_enum
Definition: DeclSpec.h:287
void CheckMain(FunctionDecl *FD, const DeclSpec &D)
Definition: SemaDecl.cpp:8585
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:503
TypedefDecl * ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo)
Subroutines of ActOnDeclarator().
Definition: SemaDecl.cpp:11524
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1744
unsigned size() const
Definition: DeclTemplate.h:91
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, AttributeList *Attrs, SourceLocation EqualLoc, Expr *Val)
Definition: SemaDecl.cpp:14093
bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S)
isMicrosoftMissingTypename - In Microsoft mode, within class scope, if a CXXScopeSpec's type is equal...
Definition: SemaDecl.cpp:539
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
Definition: SemaDecl.cpp:11317
static unsigned getNumAddressingBits(ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition: Type.cpp:77
Expr * getSubExpr()
Definition: Expr.h:2662
void ClearStorageClassSpecs()
Definition: DeclSpec.h:455
bool isForRedeclaration() const
True if this lookup is just looking for an existing declaration.
Definition: Sema/Lookup.h:219
unsigned getRegParm() const
Definition: Type.h:2916
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:11850
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:1191
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:1987
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1112
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:5664
Describes a module or submodule.
Definition: Basic/Module.h:47
IdentifierTable & Idents
Definition: ASTContext.h:451
bool isThisDeclarationADefinition() const
isThisDeclarationADefinition() - Return true if this declaration is a completion definition of the ty...
Definition: Decl.h:2782
void diagnoseMisplacedModuleImport(Module *M, SourceLocation ImportLoc)
Check if module import may be found in the current context, emit error if not.
Definition: SemaDecl.cpp:14645
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:875
RawCommentList & getRawCommentList()
Definition: ASTContext.h:684
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:102
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:917
Expr * getLHS() const
Definition: Expr.h:2921
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Decl.cpp:1006
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:391
T * getAttr() const
Definition: DeclBase.h:495
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:1769
unsigned getRegParmType() const
Definition: Type.h:2980
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:1985
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:937
Describes an C or C++ initializer list.
Definition: Expr.h:3724
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:874
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:1503
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:459
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:580
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:2370
MinSizeAttr * mergeMinSizeAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:696
const LangOptions & getLangOpts() const
Definition: ASTContext.h:596
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:1802
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:1983
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:514
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=ParsedType(), 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:241
A convenient class for passing around template argument information.
Definition: TemplateBase.h:517
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition: Decl.h:964
void setcudaConfigureCallDecl(FunctionDecl *FD)
Definition: ASTContext.h:1090
Scope * getNonFieldDeclScope(Scope *S)
getNonFieldDeclScope - Retrieves the innermost scope, starting from S, where a non-field would be dec...
Definition: SemaDecl.cpp:1683
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:2083
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:1011
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
QualType getReturnType() const
Definition: Type.h:2977
Wrapper for source info for functions.
Definition: TypeLoc.h:1255
static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, Sema &S)
Definition: SemaDecl.cpp:10790
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
Definition: SemaDecl.cpp:9626
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:4012
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:1801
AmbiguityKind getAmbiguityKind() const
Definition: Sema/Lookup.h:267
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:1764
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:5697
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
field_range fields() const
Definition: Decl.h:3295
Decl * ActOnObjCContainerStartDefinition(Decl *IDecl)
Definition: SemaDecl.cpp:12723
static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc)
Definition: SemaDecl.cpp:193
A friend of a previously-undeclared entity.
Definition: DeclBase.h:971
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3723
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:1180
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:4699
static bool isRecordType(QualType T)
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2486
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2875
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2240
void setHasObjectMember(bool val)
Definition: Decl.h:3239
An implicit 'self' parameter.
Definition: DeclSpec.h:899
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:146
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, AvailabilityMergeKind AMK, unsigned AttrSpellingListIndex)
Attribute merging methods. Return true if a new attribute was added.
static OpenCLParamType getOpenCLKernelParameterType(QualType PT)
Definition: SemaDecl.cpp:7205
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:797
void setHasImplicitReturnZero(bool IRZ)
Definition: Decl.h:1776
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:11801
child_range children()
Definition: Expr.h:3886
bool isOverloadedOperator() const
isOverloadedOperator - Whether this function declaration represents an C++ overloaded operator...
Definition: Decl.h:2009
LabelStmt * getStmt() const
Definition: Decl.h:380
void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
The parser has processed a module import translated from a #include or similar preprocessing directiv...
Definition: SemaDecl.cpp:14692
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:38
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:6046
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
Definition: SemaDecl.cpp:14599
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:651
void setTrivial(bool IT)
Definition: Decl.h:1760
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:3110
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:1551
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
void ActOnFinishInlineMethodDef(CXXMethodDecl *D)
Definition: SemaDecl.cpp:10689
bool hasUnrecoverableErrorOccurred() const
Definition: Scope.h:315
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:702
void setRedeclarationKind(Sema::RedeclarationKind RK)
Change this lookup's redeclaration kind.
Definition: Sema/Lookup.h:513
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1886
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:708
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK)
Definition: SemaDecl.cpp:2190
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:11830
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
Definition: SemaDecl.cpp:1842
void UpdateExprRep(Expr *Rep)
Definition: DeclSpec.h:664
void CheckCompleteVariableDeclaration(VarDecl *var)
Definition: SemaDecl.cpp:9957
void CheckVariableDeclarationType(VarDecl *NewVD)
Definition: SemaDecl.cpp:6500
SourceLocation getLocation() const
Definition: Attr.h:93
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:908
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:445
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:160
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:3063
void CheckMSVCRTEntryPoint(FunctionDecl *FD)
Definition: SemaDecl.cpp:8732
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:11039
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
void revertBuiltin()
Revert the identifier to a non-builtin identifier.
Represents a linkage specification.
Definition: DeclCXX.h:2454
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:497
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Sema/Lookup.h:367
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:2644
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:496
bool empty() const
Definition: Type.h:359
detail::InMemoryDirectory::const_iterator I
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared...
Definition: Sema.h:662
static bool isUsingDecl(NamedDecl *D)
Definition: SemaDecl.cpp:1309
Ordinary names.
Definition: DeclBase.h:138
CanQualType UnsignedCharTy
Definition: ASTContext.h:890
QualType getType() const
Definition: Decl.h:530
bool isInvalid() const
const LangOptions & LangOpts
Definition: Sema.h:293
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:1642
UnionParsedType ConstructorName
When Kind == IK_ConstructorName, the class-name of the type whose constructor is being referenced...
Definition: DeclSpec.h:933
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:753
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:555
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...
bool isFunctionOrFunctionTemplate() const
Whether this declaration is a function or function template.
Definition: DeclBase.h:892
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:2685
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
This object can be modified without requiring retains or releases.
Definition: Type.h:137
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:2485
param_iterator param_begin()
Definition: Decl.h:1906
unsigned getMSLastManglingNumber() const
Definition: Scope.h:294
void setHasInheritedPrototype(bool P=true)
Definition: Decl.h:1791
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
field_iterator field_end() const
Definition: Decl.h:3298
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:1782
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl)
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:63
ImplicitCaptureStyle ImpCaptureStyle
Definition: ScopeInfo.h:390
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:6820
static const Decl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2261
AnnotatingParser & P
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:1752
SmallVectorImpl< NamedDecl * >::const_iterator const_decl_iterator
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:969
bool isStatic() const
Definition: DeclCXX.cpp:1408
bool isUnion() const
Definition: Decl.h:2856
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:3647
static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)
Create a new module import declaration.
Definition: Decl.cpp:4176
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3178
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3148
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1719
void setLazyBody(uint64_t Offset)
Definition: Decl.h:1737
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:349
AvailabilityResult getAvailability(std::string *Message=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:469
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:5715
ExtInfo getExtInfo() const
Definition: Type.h:2986
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name)
Make the given externally-produced declaration visible at the top level scope.
Definition: SemaDecl.cpp:1263
Merge availability attributes for an implementation of a protocol requirement.
Definition: Sema.h:2101
llvm::APInt getValue() const
Definition: Expr.h:1234
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2045
bool Mutable
Whether this is a mutable lambda.
Definition: ScopeInfo.h:657
TST getTypeSpecType() const
Definition: DeclSpec.h:473
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:146
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Sema/Lookup.h:194
QualType getParamType(unsigned i) const
Definition: Type.h:3161
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3041
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit, bool TypeMayContainAuto)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:9194
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:113
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2510
SourceLocation getModulePrivateSpecLoc() const
Definition: DeclSpec.h:696
std::string CurrentModule
The name of the current module.
Definition: LangOptions.h:96
static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S)
mergeParamDeclAttributes - Copy attributes from the old parameter to the new one. ...
Definition: SemaDecl.cpp:2442
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:980
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:506
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5352
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:577
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:599
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1759
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:693
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:454
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1233
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:2664
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:2768
ArrayRef< NamedDecl * > getDeclsInPrototypeScope() const
Definition: Decl.h:1945
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
Captures information about a #pragma weak directive.
Definition: Weak.h:25
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1979
const CXXMethodDecl *const * method_iterator
Definition: DeclCXX.h:1793
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:5323
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:247
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:6879
static bool isDeclRep(TST T)
Definition: DeclSpec.h:407
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:534
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:1908
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1716
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
unsigned getNumExprs() const
Definition: Expr.h:4363
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1820
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1216
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Definition: ScopeInfo.h:643
bool isGlobal() const
Determines whether this is a global function.
Definition: Decl.cpp:2641
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:103
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:2282
const Type * getTypeForDecl() const
Definition: Decl.h:2507
SourceLocation getRBracketLoc() const
Definition: TypeLoc.h:1370
unsigned param_size() const
Definition: Decl.h:1900
unsigned getTypeQualifiers() const
Definition: DeclCXX.h:1817
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:521
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:5615
Expr - This represents one expression.
Definition: Expr.h:104
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Sema/Lookup.h:204
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:2632
StringRef getName() const
Return the actual identifier string.
const char * getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Definition: Builtins.h:82
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken)
Determine whether the given result set contains either a type name or.
Definition: SemaDecl.cpp:651
Represents a character-granular source range.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4202
DLLImportAttr * mergeDLLImportAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
static unsigned getMaxSizeBits(ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Definition: Type.cpp:112
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:538
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:306
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:475
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition: Type.h:3696
StateNode * Previous
static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous)
Apply special rules for handling extern "C" declarations.
Definition: SemaDecl.cpp:6469
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
bool isFunctionDefinition() const
Definition: DeclSpec.h:2219
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:1156
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:913
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Sema/Lookup.h:546
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:943
bool isModuleVisible(Module *M)
Definition: Sema.h:1385
bool isVirtual() const
Definition: DeclCXX.h:1745
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:14164
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2345
void setInit(Expr *I)
Definition: Decl.cpp:2087
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:111
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:875
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Sema/Lookup.h:458
bool isObjCGCWeak() const
true when Type is objc's weak.
Definition: Type.h:970
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
Definition: DeclSpec.h:542
bool isVariableArrayType() const
Definition: Type.h:5353
Decl * BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record)
BuildMicrosoftCAnonymousStruct - Handle the declaration of an Microsoft C anonymous structure...
Definition: SemaDecl.cpp:4379
Defines the clang::Preprocessor interface.
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
bool isInherited() const
Definition: Attr.h:97
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:849
Kind getKind() const
Definition: DeclBase.h:387
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1927
bool getNoReturn() const
Definition: Type.h:2913
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3169
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &O)
Definition: Type.h:3076
static void CheckPoppedLabel(LabelDecl *L, Sema &S)
Definition: SemaDecl.cpp:1576
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:656
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:537
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:928
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:246
DeclContext * getDeclContext()
Definition: DeclBase.h:393
void CheckAlignasUnderalignment(Decl *D)
This declaration is a tentative definition.
Definition: Decl.h:998
bool isFloatingType() const
Definition: Type.cpp:1777
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:350
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
Definition: ASTContext.h:1412
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T)
Definition: SemaDecl.cpp:13873
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2385
CanQualType ShortTy
Definition: ASTContext.h:889
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:745
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
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.
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:5259
bool isMSAsmLabel() const
Definition: Decl.h:390
bool isFunctionNoProtoType() const
Definition: Type.h:1629
bool isObjCIdType() const
Definition: Type.h:5401
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:12926
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:1388
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:1999
void UpdateTypeRep(ParsedType Rep)
Definition: DeclSpec.h:660
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
bool isConstexprSpecified() const
Definition: DeclSpec.h:698
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void setConstexpr(bool IC)
Definition: Decl.h:1192
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:13043
Expr * getAsmLabel() const
Definition: DeclSpec.h:2188
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:2287
static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D)
Definition: SemaDecl.cpp:7019
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:3105
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:4549
StorageClass
Storage classes.
Definition: Specifiers.h:198
Expr * getSubExpr() const
Definition: Expr.h:1681
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
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:711
bool isFunctionOrMethod() const
Definition: DeclBase.h:1249
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:221
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1200
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:1593
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1344
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:280
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
Definition: Decl.h:2574
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:1654
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1101
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:552
struct CXXOpName CXXOperatorName
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:190
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
DeclContext * getContainingDC(DeclContext *DC)
Definition: SemaDecl.cpp:1033
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1203
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:3561
ValueDecl * getDecl()
Definition: Expr.h:1007
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1239
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:271
void setStorageClass(StorageClass SC)
Definition: Decl.cpp:1813
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2392
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1144
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:144
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:2874
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1797
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:450
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3285
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:434
static bool shouldConsiderLinkage(const VarDecl *VD)
Definition: SemaDecl.cpp:5617
bool checkInitIsICE() const
Determine whether the value of the initializer attached to this declaration is an integral constant e...
Definition: Decl.cpp:2219
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:162
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:1241
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:602
bool isVirtualSpecified() const
Definition: DeclSpec.h:559
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:6762
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
Definition: TokenKinds.h:41
decl_range found_decls()
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:241
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:228
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:2878
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
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:90
CanQualType SignedCharTy
Definition: ASTContext.h:889
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:545
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1794
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:95
AttrVec & getAttrs()
Definition: DeclBase.h:443
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:731
param_const_iterator param_end() const
Definition: DeclObjC.h:362
bool isAmbiguous() const
Definition: Sema/Lookup.h:242
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:6386
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:144
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:10749
void addAttr(Attr *A)
Definition: DeclBase.h:449
Decl * ActOnSkippedFunctionBody(Decl *Decl)
Definition: SemaDecl.cpp:11031
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:377
UnqualifiedTypeNameLookupResult
Definition: SemaDecl.cpp:132
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:11332
static bool isIncompleteDeclExternC(Sema &S, const T *D)
Determine whether a variable is extern "C" prior to attaching an initializer.
Definition: SemaDecl.cpp:5602
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
Definition: DeclSpec.cpp:346
TypeLoc getInnerLoc() const
Definition: TypeLoc.h:1047
void setTypeForDecl(const Type *TD)
Definition: Decl.h:2508
Wrapper for source info for arrays.
Definition: TypeLoc.h:1358
static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S)
Definition: SemaDecl.cpp:3610
bool doesThisDeclarationHaveABody() const
doesThisDeclarationHaveABody - Returns whether this specific declaration of the function has a body -...
Definition: Decl.h:1732
There is no lifetime qualification on this type.
Definition: Type.h:133
ExtInfo withRegParm(unsigned RegParm) const
Definition: Type.h:2948
DeclContext * getEntity() const
Definition: Scope.h:310
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:2912
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:840
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:1814
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1540
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Definition: SemaDecl.cpp:10640
The "struct" keyword.
Definition: Type.h:4176
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition: Sema.h:2639
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:144
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
Kind
static bool hasParsedAttr(Scope *S, const AttributeList *AttrList, AttributeList::Kind Kind)
Definition: SemaDecl.cpp:5637
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5596
bool isConst(unsigned ID) const
Return true if this function has no side effects and doesn't read memory.
Definition: Builtins.h:98
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:1481
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:3727
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
enum clang::DeclaratorChunk::@183 Kind
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:187
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:14334
SourceLocation getOuterLocStart() const
getOuterLocStart - Return SourceLocation representing start of source range taking into account any o...
Definition: Decl.cpp:1695
OverrideErrorKind
Definition: SemaDecl.cpp:6753
ExternCContextDecl * getExternCContextDecl() const
Definition: ASTContext.cpp:906
Encodes a location in the source.
enumerator_range enumerators() const
Definition: Decl.h:3026
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Determines whether this field is a representative for an anonymous struct ...
Definition: Decl.cpp:3453
Sugar for parentheses used when specifying types.
Definition: Type.h:2116
void setTopLevelDeclInObjCContainer(bool V=true)
Definition: DeclBase.h:552
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:8752
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2743
SourceLocation CurrentPragmaLocation
Definition: Sema.h:381
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3570
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5089
const TemplateArgument * iterator
Definition: Type.h:4070
bool containedInPrototypeScope() const
containedInPrototypeScope - Return true if this or a parent scope is a FunctionPrototypeScope.
Definition: Scope.cpp:94
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3463
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:1583
bool isPredefinedRuntimeFunction(unsigned ID) const
Determines whether this builtin is a predefined compiler-rt/libgcc function, such as "__clear_cache"...
Definition: Builtins.h:139
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition: ScopeInfo.h:640
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:885
Expr * getRepAsExpr() const
Definition: DeclSpec.h:489
bool isShadowed() const
Determine whether the lookup result was shadowed by some other declaration that lookup ignored...
Definition: Sema/Lookup.h:400
DLLExportAttr * mergeDLLExportAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1731
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:10142
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isExplicit, bool isInline, bool isImplicitlyDeclared, bool isConstexpr)
Definition: DeclCXX.cpp:1755
void AddKnownFunctionAttributes(FunctionDecl *FD)
Adds any function attributes that we know a priori based on the declaration of this function...
Definition: SemaDecl.cpp:11427
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Definition: SemaDecl.cpp:14780
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:2811
reference front() const
Definition: DeclBase.h:1096
void ExitDeclaratorContext(Scope *S)
Definition: SemaDecl.cpp:1133
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
Definition: DeclBase.h:198
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2644
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
attr_range attrs() const
Definition: DeclBase.h:459
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:311
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:1048
bool isLocalVarDecl() const
isLocalVarDecl - Returns true for local variable declarations other than parameters.
Definition: Decl.h:955
static const TST TST_union
Definition: DeclSpec.h:288
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:92
CommonAttr * mergeCommonAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:355
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:493
ParsedType getRepAsType() const
Definition: DeclSpec.h:481
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:178
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1701
void setDefaulted(bool D=true)
Definition: Decl.h:1765
void setHasFlexibleArrayMember(bool V)
Definition: Decl.h:3219
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:10995
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
Definition: SemaType.cpp:6540
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
void addOverriddenMethod(const CXXMethodDecl *MD)
Definition: DeclCXX.cpp:1574
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:716
void setEntity(DeclContext *E)
Definition: Scope.h:311
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:6900
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:2934
SourceRange getExceptionSpecRange() const
Definition: DeclSpec.h:1342
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
SourceLocation getStrTokenLoc(unsigned TokNum) const
Definition: Expr.h:1562
A friend of a previously-declared entity.
Definition: DeclBase.h:970
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Sema/Lookup.h:52
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1435
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:1931
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:699
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:3188
CanQualType VoidTy
Definition: ASTContext.h:881
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
decl_range decls() const
Definition: Scope.h:267
Describes the kind of initialization being performed, along with location information for tokens rela...
bool hasVolatileMember() const
Definition: Decl.h:3241
arg_range arguments()
Definition: Expr.h:2224
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or NULL if no such declaration exists...
Definition: DeclTemplate.h:917
A class for iterating through a result set and possibly filtering out results.
Definition: Sema/Lookup.h:557
This declaration is only a declaration.
Definition: Decl.h:997
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:560
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2712
static const TST TST_typeofType
Definition: DeclSpec.h:293
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:164
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5706
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:1368
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:4413
bool isFileContext() const
Definition: DeclBase.h:1265
static bool AllowOverloadingOfFunction(LookupResult &Previous, ASTContext &Context)
Determine whether we allow overloading of the function PrevDecl with another declaration.
Definition: SemaDecl.cpp:1190
PtrTy get() const
Definition: Ownership.h:74
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
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:95
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:2818
void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl< Decl * > &AllIvarDecls)
ActOnLastBitfield - This routine handles synthesized bitfields rules for class and class extensions...
Definition: SemaDecl.cpp:13408
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2693
Expr ** getExprs()
Definition: Expr.h:4375
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2314
bool isStaticMember()
Returns true if this declares a static member.
Definition: DeclSpec.cpp:338
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:4184
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:1983
Assigning into this object requires a lifetime extension.
Definition: Type.h:150
bool hasObjectMember() const
Definition: Decl.h:3238
static bool isExternC(T *D)
Definition: SemaDecl.cpp:2596
Attr * clone(ASTContext &C) const
void dropAttrs()
Definition: DeclBase.cpp:676
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5159
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:130
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
Definition: SemaDecl.cpp:13442
void setObjCSuperType(QualType ST)
Definition: ASTContext.h:1378
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:645
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:536
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:13857
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
Definition: DeclSpec.h:2215
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:69
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:1695
Opcode getOpcode() const
Definition: Expr.h:1678
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for redeclaration diagnostic message.
Definition: SemaDecl.cpp:11643
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:3658
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:1630
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1235
QualType getPointeeType() const
Definition: Type.h:2161
void setVirtualAsWritten(bool V)
Definition: Decl.h:1744
A constructor named via a template-id.
Definition: DeclSpec.h:893
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:2525
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
C++11 thread_local.
Definition: Specifiers.h:191
bool containsPlaceholderType() const
Definition: DeclSpec.h:514
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
Definition: ASTContext.h:1603
static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext *, ASTContext &)
Determines whether the given declaration is an out-of-scope previous declaration. ...
Definition: SemaDecl.cpp:5307
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1743
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
Definition: DeclSpec.h:2155
AttributeFactory & getFactory() const
CanQualType UnsignedShortTy
Definition: ASTContext.h:890
param_range params()
Definition: Decl.h:1910
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1207
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
Definition: Builtins.h:92
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:14737
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
attr::Kind getKind() const
Definition: Attr.h:86
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2526
QualType getType() const
Definition: Expr.h:125
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3233
CanQualType CharTy
Definition: ASTContext.h:883
TLS with a dynamic initializer.
Definition: Decl.h:718
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:1147
ParsedType ActOnDelayedDefaultTemplateArg(const IdentifierInfo &II, SourceLocation NameLoc)
For compatibility with MSVC, we delay parsing of some default template type arguments until instantia...
Definition: SemaDecl.cpp:474
void setBody(Stmt *B)
Definition: Decl.cpp:2507
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2195
static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.h:71
TagTypeKind
The kind of a tag type.
Definition: Type.h:4174
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:442
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2334
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:1961
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:5085
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:1992
void setHasVolatileMember(bool val)
Definition: Decl.h:3242
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:10516
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5055
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1121
unsigned getMSCurManglingNumber() const
Definition: Scope.h:300
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1862
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:331
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:1104
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Sema/Lookup.h:214
A template instantiation that is currently in progress.
Definition: Sema.h:6481
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
static const TST TST_decltype
Definition: DeclSpec.h:295
SmallVectorImpl< UniqueVirtualMethod >::iterator overriding_iterator
static const TST TST_auto
Definition: DeclSpec.h:298
bool isFriendSpecified() const
Definition: DeclSpec.h:692
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1210
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:1723
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:759
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:3955
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:441
void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, SourceLocation RBraceLoc, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, AttributeList *Attr)
Definition: SemaDecl.cpp:14363
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceLocation RBraceLoc)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
Definition: SemaDecl.cpp:12770
bool isInvalidDecl() const
Definition: DeclBase.h:509
OpenCLParamType
Definition: SemaDecl.cpp:7196
bool getProducesResult() const
Definition: Type.h:2914
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:11600
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2437
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1056
void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod)
The parsed has entered a submodule.
Definition: SemaDecl.cpp:14719
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Definition: SemaExpr.cpp:13836
unsigned getNextFunctionPrototypeIndex()
Return the number of parameters declared in this function prototype, increasing it by one for the nex...
Definition: Scope.h:261
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:891
bool isMissingDeclaratorOk()
Checks if this DeclSpec can stand alone, without a Declarator.
Definition: DeclSpec.cpp:1222
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:3023
const llvm::APSInt & getInitVal() const
Definition: Decl.h:2416
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1216
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:75
virtual void HandleImplicitImportDecl(ImportDecl *D)
Handle an ImportDecl that was implicitly created due to an inclusion directive.
Definition: ASTConsumer.cpp:30
void setShadowed()
Note that we found and ignored a declaration while performing lookup.
Definition: Sema/Lookup.h:404
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:1170
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:13282
CallingConv getCC() const
Definition: Type.h:2922
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5062
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
Definition: SemaDecl.cpp:3616
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
bool isUsed(bool CheckUsedAttr=true) const
Whether this declaration was used, meaning that a definition is required.
Definition: DeclBase.cpp:332
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1069
static FunctionDecl * CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay)
Definition: SemaDecl.cpp:7054
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:1500
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:1725
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:624
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
EnumDecl - Represents an enum.
Definition: Decl.h:2930
bool hasAttrs() const
Definition: DeclBase.h:439
VisibilityAttr * mergeVisibilityAttr(Decl *D, SourceRange Range, VisibilityAttr::VisibilityType Vis, unsigned AttrSpellingListIndex)
detail::InMemoryDirectory::const_iterator E
void mergeNRVOIntoParent()
Definition: Scope.cpp:118
QualType getModifiedType() const
Definition: Type.h:3665
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc)
Definition: SemaDecl.cpp:666
bool isSimpleTypeSpecifier(tok::TokenKind Kind) const
Determine whether the token kind starts a simple-type-specifier.
Definition: SemaDecl.cpp:94
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
bool isHalfType() const
Definition: Type.h:5552
SourceLocation getNoreturnSpecLoc() const
Definition: DeclSpec.h:566
bool hasName() const
hasName - Whether this declarator has a name, which might be an identifier (accessible via getIdentif...
Definition: DeclSpec.h:1947
bool isSamplerT() const
Definition: Type.h:5468
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2187
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Sema/Lookup.h:249
static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D)
Definition: SemaDecl.cpp:1449
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1946
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:12733
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:3763
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void setPreviousDeclInSameBlockScope(bool Same)
Definition: Decl.h:1222
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:3621
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
Definition: SemaDecl.cpp:10574
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:4118
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:1459
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
std::string ImplementationOfModule
The name of the module that the translation unit is an implementation of.
Definition: LangOptions.h:101
bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D)
Definition: SemaInternal.h:54
void setConcept(bool IC)
Definition: Decl.h:1201
const RecordType * getAsStructureType() const
Definition: Type.cpp:431
static std::pair< diag::kind, SourceLocation > getNoteDiagForInvalidRedeclaration(const T *Old, const T *New)
Definition: SemaDecl.cpp:2550
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration...
Definition: DeclBase.h:939
All of the names in this module are visible.
Definition: Basic/Module.h:210
known_extensions_range known_extensions() const
Definition: DeclObjC.h:1425
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2551
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2097
param_iterator param_end()
Definition: Decl.h:1907
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration...
Definition: DeclBase.h:912
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:2090
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:2752
NamedDecl * ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous)
Definition: SemaDecl.cpp:5176
void RemoveDecl(Decl *D)
Definition: Scope.h:276
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:280
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:1643
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:5380
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2220
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
void DiagnoseUnusedParameters(ParmVarDecl *const *Begin, ParmVarDecl *const *End)
Diagnose any unused parameters in the given sequence of ParmVarDecl pointers.
Definition: SemaDecl.cpp:10529
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:97
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3544
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition: Decl.h:3097
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:528
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
SourceManager & getSourceManager() const
Definition: Sema.h:1046
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3584
CanQualType UnknownAnyTy
Definition: ASTContext.h:896
void ActOnTagDefinitionError(Scope *S, Decl *TagDecl)
ActOnTagDefinitionError - Invoked when there was an unrecoverable error parsing the definition of a t...
Definition: SemaDecl.cpp:12814
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint)
Definition: SemaDecl.cpp:1524
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
QualType getCanonicalType() const
Definition: Type.h:5128
ValueType CurrentValue
Definition: Sema.h:380
UsingDecl * getUsingDecl() const
Gets the using declaration to which this declaration is tied.
Definition: DeclCXX.cpp:2099
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
Definition: DeclSpec.h:1194
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:148
CanQualType UnsignedLongTy
Definition: ASTContext.h:890
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, Expr *Cpy)
Definition: ScopeInfo.h:848
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition: DeclBase.h:987
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1649
bool isRedeclaration() const
Definition: DeclSpec.h:2241
bool isDeduced() const
Definition: Type.h:3948
CanQualType DependentTy
Definition: ASTContext.h:896
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:1268
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
Definition: SemaDecl.cpp:13896
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:1273
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3054
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:607
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
bool isFunctionType() const
Definition: Type.h:5302
static const TST TST_typename
Definition: DeclSpec.h:292
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1275
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1495
CXXConstructorDecl * getConstructor() const
Definition: ExprCXX.h:1211
const DeclarationNameLoc & getInfo() const
static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D)
Definition: SemaDecl.cpp:5346
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:1522
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1759
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:978
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:10272
void CheckShadow(Scope *S, VarDecl *D, const LookupResult &R)
Diagnose variable or built-in function shadowing.
Definition: SemaDecl.cpp:6299
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:14755
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:1473
void setCXXForRangeDecl(bool FRD)
Definition: Decl.h:1171
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:9888
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:4116
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
Definition: Sema/Lookup.h:387
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:1257
static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record)
Definition: SemaDecl.cpp:4081
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
void setInherited(bool I)
Definition: Attr.h:128
void setBlockVarCopyInits(VarDecl *VD, Expr *Init)
Set the copy inialization expression of a block var decl.
bool isInlineSpecified() const
Definition: DeclSpec.h:552
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs, SourceLocation AttrEnd)
Definition: SemaDecl.cpp:9927
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:4182
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:897
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:14649
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:986
Represents a base class of a C++ class.
Definition: DeclCXX.h:157
CXXScopeSpec & getTypeSpecScope()
Definition: DeclSpec.h:493
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2354
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:14611
bool isUsable() const
Definition: Ownership.h:160
This is a scope that can contain a declaration.
Definition: Scope.h:57
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:141
SourceManager & getSourceManager()
Definition: ASTContext.h:553
void * SkippedDefinitionContext
Definition: Sema.h:1966
bool isTLSSupported() const
Whether the target supports thread-local storage.
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1951
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:682
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
Definition: SemaDecl.cpp:4781
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:3277
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e...
Definition: SemaDecl.cpp:3599
void setPromotionType(QualType T)
Set the promotion type.
Definition: Decl.h:3049
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
Definition: SemaDecl.cpp:1634
Expr * getBase() const
Definition: Expr.h:2387
bool isFunctionPrototypeScope() const
isFunctionPrototypeScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:368
const DeclContext * getCurObjCLexicalContext() const
Definition: Sema.h:9214
bool isObjCGCStrong() const
true when Type is objc's strong.
Definition: Type.h:975
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2199
Reading or writing from this object requires a barrier call.
Definition: Type.h:147
QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init)
Definition: SemaDecl.cpp:9101
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:11656
static bool isMainFileLoc(const Sema &S, SourceLocation Loc)
Definition: SemaDecl.cpp:1372
bool isPODType(ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1961
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:3598
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:315
Call-style initialization (C++98)
Definition: Decl.h:710
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:2297
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:185
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:5017
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:11821
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
bool isExplicitSpecified() const
Definition: DeclSpec.h:562
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:1957
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum...
Definition: Decl.h:3080
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...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
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 bool isCompoundAssignmentOp(Opcode Opc)
Definition: Expr.h:3005
static const TSCS TSCS_thread_local
Definition: DeclSpec.h:248
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition: Decl.h:880
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:889
static void RemoveUsingDecls(LookupResult &R)
Removes using shadow declarations from the lookup results.
Definition: SemaDecl.cpp:1316
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:3380
bool isObjCObjectPointerType() const
Definition: Type.h:5377
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2287
Represents a C array with an unspecified size.
Definition: Type.h:2530
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name)
NeedsRebuildingInCurrentInstantiation - Checks whether the given declarator needs to be rebuilt in th...
Definition: SemaDecl.cpp:4584
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:12833
Missing a type from <stdio.h>
Definition: ASTContext.h:1738
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:2668
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:2059
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3218
void setConstexpr(bool IC)
Definition: Decl.h:1795
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:482
static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B)
Definition: SemaDecl.cpp:2638
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:43
static bool anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned NumArgs, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1609
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4060
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:118
Capturing by reference.
Definition: Lambda.h:37
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:323
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1031
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:453
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
The "enum" keyword.
Definition: Type.h:4184
bool isEventT() const
Definition: Type.h:5472
void ActOnPopScope(SourceLocation Loc, Scope *S)
Scope actions.
Definition: SemaDecl.cpp:1590
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:853
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1189
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:4060
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:2011
void addVLATypeCapture(SourceLocation Loc, QualType CaptureType)
Definition: ScopeInfo.h:521
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:355
SmallVectorImpl< NamedDecl * >::iterator decl_iterator
LookupResultKind getResultKind() const
Definition: Sema/Lookup.h:262
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:477
bool isArrayType() const
Definition: Type.h:5344
decl_iterator end()
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:917
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1452
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2134
Expr * getRHS() const
Definition: Expr.h:2923
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, NamedDecl **CH, unsigned CHS)
Definition: Decl.cpp:4038
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1316
TLS with a known-constant initializer.
Definition: Decl.h:717
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3341
AvailabilityResult getCurContextAvailability() const
Definition: SemaDecl.cpp:14817
ExprResult ExprError()
Definition: Ownership.h:267
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:3067
The translation unit is a complete translation unit.
Definition: LangOptions.h:180
void DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl *const *Begin, ParmVarDecl *const *End, 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:10545
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:2919
bool getHasRegParm() const
Definition: Type.h:2915
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
Definition: ASTContext.h:1439
static bool DeclHasAttr(const Decl *D, const Attr *A)
DeclhasAttr - returns true if decl Declaration already has the target attribute.
Definition: SemaDecl.cpp:2052
bool isIncompleteArrayType() const
Definition: Type.h:5350
CanQualType IntTy
Definition: ASTContext.h:889
bool isRecord() const
Definition: DeclBase.h:1273
static OpaquePtr make(QualTypeP)
Definition: Ownership.h:54
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:2603
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:166
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:79
CK_NoOp - A conversion which does not affect the type other than (possibly) adding qualifiers...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:922
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:132
static const TST TST_atomic
Definition: DeclSpec.h:301
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:2458
NamedDecl * findLocallyScopedExternCDecl(DeclarationName Name)
Look for a locally scoped extern "C" declaration by the given name.
Definition: SemaDecl.cpp:5147
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:953
void ActOnObjCContainerFinishDefinition()
Definition: SemaDecl.cpp:12798
SourceManager & SourceMgr
Definition: Sema.h:298
bool isResolvedMSAsmLabel() const
Definition: Decl.h:391
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:289
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:513
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3197
SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD)
Invoked when we enter a tag definition that we're skipping.
Definition: SemaDecl.cpp:1083
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:10130
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Sema/Lookup.h:523
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:1987
void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod)
The parser has left a submodule.
Definition: SemaDecl.cpp:14727
AttributeList * getNext() const
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2643
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:106
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1034
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:384
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:3066
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:245
ASTContext & Context
Definition: Sema.h:295
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
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2682
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:978
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1668
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
Definition: ASTContext.h:1500
bool isInvalidType() const
Definition: DeclSpec.h:2200
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
Definition: ASTContext.h:1478
void dropAttr()
Definition: DeclBase.h:471
bool isModulePrivateSpecified() const
Definition: DeclSpec.h:695
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:2571
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:423
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2575
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:4204
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D)
Check for this common pattern:
Definition: SemaDecl.cpp:1332
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5148
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition: Decl.h:1775
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND)
Definition: SemaDecl.cpp:5396
SourceLocation EndLocation
The location of the last token that describes this unqualified-id.
Definition: DeclSpec.h:951
static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous)
Definition: SemaDecl.cpp:3343
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2561
LambdaCaptureDefault getLambdaCaptureDefault() const
Definition: DeclCXX.h:1047
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:3438
unsigned NumArgs
NumArgs - The number of template arguments.
Decl * getObjCDeclContext() const
Definition: SemaDecl.cpp:14813
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
Definition: DeclSpec.h:2228
NamedDecl * Previous
Definition: Sema.h:1471
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:600
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
Definition: SemaDecl.cpp:3225
Missing a type from <setjmp.h>
Definition: ASTContext.h:1739
void setType(QualType newType)
Definition: Decl.h:531
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:3476
ParsedAttributes - A collection of parsed attributes.
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:1822
static bool isAttributeTargetADefinition(Decl *D)
Definition: SemaDecl.cpp:2071
No in-class initializer.
Definition: Specifiers.h:222
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
Definition: SemaDecl.cpp:4426
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:2799
bool isIntegralType(ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1619
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:830
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
Definition: Sema.h:908
iterator - Iterate over the decls of a specified declaration name.
void clear()
Clears out any current state.
Definition: Sema/Lookup.h:495
A class which abstracts out some details necessary for making a call.
Definition: Type.h:2872
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1272
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1730
Attr - This represents one attribute.
Definition: Attr.h:44
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:741
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2766
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:891
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:2764
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:2371
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2385
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2433
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1712
Decl * ActOnDeclarator(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:4653
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:72
CanQualType UnsignedIntTy
Definition: ASTContext.h:890
static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl< const Type * > &ValidTypes)
Definition: SemaDecl.cpp:7235
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5116
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:1290
bool isPointerType() const
Definition: Type.h:5305
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:645
bool isPOD() const
Whether this class is a POD-type (C++ [class]p4)
Definition: DeclCXX.h:1130
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:601
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
Definition: SemaDecl.cpp:1537
bool hasInit() const
Definition: Decl.cpp:2034
The translation unit is a module.
Definition: LangOptions.h:185
const AttributeList * getAttributes() const
Definition: DeclSpec.h:2162
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:130
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:3945