/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp
Warning:	line 154, column 12 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaCXXScopeSpec.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCXXScopeSpec.cpp

→

1//===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements C++ semantic analysis for scope specifiers.
10//
11//===----------------------------------------------------------------------===//

13#include "TypeLocBuilder.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/DeclTemplate.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/AST/NestedNameSpecifier.h"
18#include "clang/Basic/PartialDiagnostic.h"
19#include "clang/Sema/DeclSpec.h"
20#include "clang/Sema/Lookup.h"
21#include "clang/Sema/SemaInternal.h"
22#include "clang/Sema/Template.h"
23#include "llvm/ADT/STLExtras.h"
24using namespace clang;

26/// Find the current instantiation that associated with the given type.
27static CXXRecordDecl *getCurrentInstantiationOf(QualType T,
                                              DeclContext *CurContext) {
if (T.isNull())
  return nullptr;

const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
  CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
  if (!Record->isDependentContext() ||
      Record->isCurrentInstantiation(CurContext))
    return Record;

  return nullptr;
} else if (isa<InjectedClassNameType>(Ty))
  return cast<InjectedClassNameType>(Ty)->getDecl();
else
  return nullptr;
44}

46/// Compute the DeclContext that is associated with the given type.
47///
48/// \param T the type for which we are attempting to find a DeclContext.
49///
50/// \returns the declaration context represented by the type T,
51/// or NULL if the declaration context cannot be computed (e.g., because it is
52/// dependent and not the current instantiation).
53DeclContext *Sema::computeDeclContext(QualType T) {
if (!T->isDependentType())
  if (const TagType *Tag = T->getAs<TagType>())
    return Tag->getDecl();

return ::getCurrentInstantiationOf(T, CurContext);
59}

61/// Compute the DeclContext that is associated with the given
62/// scope specifier.
63///
64/// \param SS the C++ scope specifier as it appears in the source
65///
66/// \param EnteringContext when true, we will be entering the context of
67/// this scope specifier, so we can retrieve the declaration context of a
68/// class template or class template partial specialization even if it is
69/// not the current instantiation.
70///
71/// \returns the declaration context represented by the scope specifier @p SS,
72/// or NULL if the declaration context cannot be computed (e.g., because it is
73/// dependent and not the current instantiation).
74DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS,
                                    bool EnteringContext) {
if (!SS.isSet() || SS.isInvalid())
3
←
Calling 'CXXScopeSpec::isSet'→
6
←
Returning from 'CXXScopeSpec::isSet'→
7
←
Calling 'CXXScopeSpec::isInvalid'→
9
←
Returning from 'CXXScopeSpec::isInvalid'→
10
←
Taking false branch→
  return nullptr;

NestedNameSpecifier *NNS = SS.getScopeRep();
if (NNS->isDependent()) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
  // If this nested-name-specifier refers to the current
  // instantiation, return its DeclContext.
  if (CXXRecordDecl *Record = getCurrentInstantiationOf(NNS))
    return Record;

  if (EnteringContext) {
    const Type *NNSType = NNS->getAsType();
    if (!NNSType) {
      return nullptr;
    }

    // Look through type alias templates, per C++0x [temp.dep.type]p1.
    NNSType = Context.getCanonicalType(NNSType);
    if (const TemplateSpecializationType *SpecType
          = NNSType->getAs<TemplateSpecializationType>()) {
      // We are entering the context of the nested name specifier, so try to
      // match the nested name specifier to either a primary class template
      // or a class template partial specialization.
      if (ClassTemplateDecl *ClassTemplate
            = dyn_cast_or_null<ClassTemplateDecl>(
                          SpecType->getTemplateName().getAsTemplateDecl())) {
        QualType ContextType
          = Context.getCanonicalType(QualType(SpecType, 0));

        // If the type of the nested name specifier is the same as the
        // injected class name of the named class template, we're entering
        // into that class template definition.
        QualType Injected
          = ClassTemplate->getInjectedClassNameSpecialization();
        if (Context.hasSameType(Injected, ContextType))
          return ClassTemplate->getTemplatedDecl();

        // If the type of the nested name specifier is the same as the
        // type of one of the class template's class template partial
        // specializations, we're entering into the definition of that
        // class template partial specialization.
        if (ClassTemplatePartialSpecializationDecl *PartialSpec
              = ClassTemplate->findPartialSpecialization(ContextType)) {
          // A declaration of the partial specialization must be visible.
          // We can always recover here, because this only happens when we're
          // entering the context, and that can't happen in a SFINAE context.
          assert(!isSFINAEContext() &&((void)0)
                 "partial specialization scope specifier in SFINAE context?")((void)0);
          if (!hasVisibleDeclaration(PartialSpec))
            diagnoseMissingImport(SS.getLastQualifierNameLoc(), PartialSpec,
                                  MissingImportKind::PartialSpecialization,
                                  /*Recover*/true);
          return PartialSpec;
        }
      }
    } else if (const RecordType *RecordT = NNSType->getAs<RecordType>()) {
      // The nested name specifier refers to a member of a class template.
      return RecordT->getDecl();
    }
  }

  return nullptr;
}

switch (NNS->getKind()) {
13
←
Control jumps to 'case TypeSpecWithTemplate:'  at line 151→
case NestedNameSpecifier::Identifier:
  llvm_unreachable("Dependent nested-name-specifier has no DeclContext")__builtin_unreachable();

case NestedNameSpecifier::Namespace:
  return NNS->getAsNamespace();

case NestedNameSpecifier::NamespaceAlias:
  return NNS->getAsNamespaceAlias()->getNamespace();

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
  const TagType *Tag = NNS->getAsType()->getAs<TagType>();
14
←
Assuming the object is not a 'TagType'→
15
←
'Tag' initialized to a null pointer value→
  assert(Tag && "Non-tag type in nested-name-specifier")((void)0);
  return Tag->getDecl();
16
←
Called C++ object pointer is null
}

case NestedNameSpecifier::Global:
  return Context.getTranslationUnitDecl();

case NestedNameSpecifier::Super:
  return NNS->getAsRecordDecl();
}

llvm_unreachable("Invalid NestedNameSpecifier::Kind!")__builtin_unreachable();
165}

167bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) {
if (!SS.isSet() || SS.isInvalid())
  return false;

return SS.getScopeRep()->isDependent();
172}

174/// If the given nested name specifier refers to the current
175/// instantiation, return the declaration that corresponds to that
176/// current instantiation (C++0x [temp.dep.type]p1).
177///
178/// \param NNS a dependent nested name specifier.
179CXXRecordDecl *Sema::getCurrentInstantiationOf(NestedNameSpecifier *NNS) {
assert(getLangOpts().CPlusPlus && "Only callable in C++")((void)0);
assert(NNS->isDependent() && "Only dependent nested-name-specifier allowed")((void)0);

if (!NNS->getAsType())
  return nullptr;

QualType T = QualType(NNS->getAsType(), 0);
return ::getCurrentInstantiationOf(T, CurContext);
188}

190/// Require that the context specified by SS be complete.
191///
192/// If SS refers to a type, this routine checks whether the type is
193/// complete enough (or can be made complete enough) for name lookup
194/// into the DeclContext. A type that is not yet completed can be
195/// considered "complete enough" if it is a class/struct/union/enum
196/// that is currently being defined. Or, if we have a type that names
197/// a class template specialization that is not a complete type, we
198/// will attempt to instantiate that class template.
199bool Sema::RequireCompleteDeclContext(CXXScopeSpec &SS,
                                    DeclContext *DC) {
assert(DC && "given null context")((void)0);

TagDecl *tag = dyn_cast<TagDecl>(DC);

// If this is a dependent type, then we consider it complete.
// FIXME: This is wrong; we should require a (visible) definition to
// exist in this case too.
if (!tag || tag->isDependentContext())
  return false;

// Grab the tag definition, if there is one.
QualType type = Context.getTypeDeclType(tag);
tag = type->getAsTagDecl();

// If we're currently defining this type, then lookup into the
// type is okay: don't complain that it isn't complete yet.
if (tag->isBeingDefined())
  return false;

SourceLocation loc = SS.getLastQualifierNameLoc();
if (loc.isInvalid()) loc = SS.getRange().getBegin();

// The type must be complete.
if (RequireCompleteType(loc, type, diag::err_incomplete_nested_name_spec,
                        SS.getRange())) {
  SS.SetInvalid(SS.getRange());
  return true;
}

if (auto *EnumD = dyn_cast<EnumDecl>(tag))
  // Fixed enum types and scoped enum instantiations are complete, but they
  // aren't valid as scopes until we see or instantiate their definition.
  return RequireCompleteEnumDecl(EnumD, loc, &SS);

return false;
236}

238/// Require that the EnumDecl is completed with its enumerators defined or
239/// instantiated. SS, if provided, is the ScopeRef parsed.
240///
241bool Sema::RequireCompleteEnumDecl(EnumDecl *EnumD, SourceLocation L,
                                 CXXScopeSpec *SS) {
if (EnumD->isCompleteDefinition()) {
  // If we know about the definition but it is not visible, complain.
  NamedDecl *SuggestedDef = nullptr;
  if (!hasVisibleDefinition(EnumD, &SuggestedDef,
                            /*OnlyNeedComplete*/false)) {
    // If the user is going to see an error here, recover by making the
    // definition visible.
    bool TreatAsComplete = !isSFINAEContext();
    diagnoseMissingImport(L, SuggestedDef, MissingImportKind::Definition,
                          /*Recover*/ TreatAsComplete);
    return !TreatAsComplete;
  }
  return false;
}

// Try to instantiate the definition, if this is a specialization of an
// enumeration temploid.
if (EnumDecl *Pattern = EnumD->getInstantiatedFromMemberEnum()) {
  MemberSpecializationInfo *MSI = EnumD->getMemberSpecializationInfo();
  if (MSI->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) {
    if (InstantiateEnum(L, EnumD, Pattern,
                        getTemplateInstantiationArgs(EnumD),
                        TSK_ImplicitInstantiation)) {
      if (SS)
        SS->SetInvalid(SS->getRange());
      return true;
    }
    return false;
  }
}

if (SS) {
  Diag(L, diag::err_incomplete_nested_name_spec)
      << QualType(EnumD->getTypeForDecl(), 0) << SS->getRange();
  SS->SetInvalid(SS->getRange());
} else {
  Diag(L, diag::err_incomplete_enum) << QualType(EnumD->getTypeForDecl(), 0);
  Diag(EnumD->getLocation(), diag::note_declared_at);
}

return true;
284}

286bool Sema::ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc,
                                      CXXScopeSpec &SS) {
SS.MakeGlobal(Context, CCLoc);
return false;
290}

292bool Sema::ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
                                  SourceLocation ColonColonLoc,
                                  CXXScopeSpec &SS) {
CXXRecordDecl *RD = nullptr;
for (Scope *S = getCurScope(); S; S = S->getParent()) {
  if (S->isFunctionScope()) {
    if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(S->getEntity()))
      RD = MD->getParent();
    break;
  }
  if (S->isClassScope()) {
    RD = cast<CXXRecordDecl>(S->getEntity());
    break;
  }
}

if (!RD) {
  Diag(SuperLoc, diag::err_invalid_super_scope);
  return true;
} else if (RD->isLambda()) {
  Diag(SuperLoc, diag::err_super_in_lambda_unsupported);
  return true;
} else if (RD->getNumBases() == 0) {
  Diag(SuperLoc, diag::err_no_base_classes) << RD->getName();
  return true;
}

SS.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
return false;
321}

323/// Determines whether the given declaration is an valid acceptable
324/// result for name lookup of a nested-name-specifier.
325/// \param SD Declaration checked for nested-name-specifier.
326/// \param IsExtension If not null and the declaration is accepted as an
327/// extension, the pointed variable is assigned true.
328bool Sema::isAcceptableNestedNameSpecifier(const NamedDecl *SD,
                                         bool *IsExtension) {
if (!SD)
  return false;

SD = SD->getUnderlyingDecl();

// Namespace and namespace aliases are fine.
if (isa<NamespaceDecl>(SD))
  return true;

if (!isa<TypeDecl>(SD))
  return false;

// Determine whether we have a class (or, in C++11, an enum) or
// a typedef thereof. If so, build the nested-name-specifier.
QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
if (T->isDependentType())
  return true;
if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) {
  if (TD->getUnderlyingType()->isRecordType())
    return true;
  if (TD->getUnderlyingType()->isEnumeralType()) {
    if (Context.getLangOpts().CPlusPlus11)
      return true;
    if (IsExtension)
      *IsExtension = true;
  }
} else if (isa<RecordDecl>(SD)) {
  return true;
} else if (isa<EnumDecl>(SD)) {
  if (Context.getLangOpts().CPlusPlus11)
    return true;
  if (IsExtension)
    *IsExtension = true;
}

return false;
366}

368/// If the given nested-name-specifier begins with a bare identifier
369/// (e.g., Base::), perform name lookup for that identifier as a
370/// nested-name-specifier within the given scope, and return the result of that
371/// name lookup.
372NamedDecl *Sema::FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS) {
if (!S || !NNS)
  return nullptr;

while (NNS->getPrefix())
  NNS = NNS->getPrefix();

if (NNS->getKind() != NestedNameSpecifier::Identifier)
  return nullptr;

LookupResult Found(*this, NNS->getAsIdentifier(), SourceLocation(),
                   LookupNestedNameSpecifierName);
LookupName(Found, S);
assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet")((void)0);

if (!Found.isSingleResult())
  return nullptr;

NamedDecl *Result = Found.getFoundDecl();
if (isAcceptableNestedNameSpecifier(Result))
  return Result;

return nullptr;
395}

397bool Sema::isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
                                      NestedNameSpecInfo &IdInfo) {
QualType ObjectType = GetTypeFromParser(IdInfo.ObjectType);
LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
                   LookupNestedNameSpecifierName);

// Determine where to perform name lookup
DeclContext *LookupCtx = nullptr;
bool isDependent = false;
if (!ObjectType.isNull()) {
  // This nested-name-specifier occurs in a member access expression, e.g.,
  // x->B::f, and we are looking into the type of the object.
  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist")((void)0);
  LookupCtx = computeDeclContext(ObjectType);
  isDependent = ObjectType->isDependentType();
} else if (SS.isSet()) {
  // This nested-name-specifier occurs after another nested-name-specifier,
  // so long into the context associated with the prior nested-name-specifier.
  LookupCtx = computeDeclContext(SS, false);
  isDependent = isDependentScopeSpecifier(SS);
  Found.setContextRange(SS.getRange());
}

if (LookupCtx) {
  // Perform "qualified" name lookup into the declaration context we
  // computed, which is either the type of the base of a member access
  // expression or the declaration context associated with a prior
  // nested-name-specifier.

  // The declaration context must be complete.
  if (!LookupCtx->isDependentContext() &&
      RequireCompleteDeclContext(SS, LookupCtx))
    return false;

  LookupQualifiedName(Found, LookupCtx);
} else if (isDependent) {
  return false;
} else {
  LookupName(Found, S);
}
Found.suppressDiagnostics();

return Found.getAsSingle<NamespaceDecl>();
440}

442namespace {

444// Callback to only accept typo corrections that can be a valid C++ member
445// intializer: either a non-static field member or a base class.
446class NestedNameSpecifierValidatorCCC final
  : public CorrectionCandidateCallback {
448public:
explicit NestedNameSpecifierValidatorCCC(Sema &SRef)
    : SRef(SRef) {}

bool ValidateCandidate(const TypoCorrection &candidate) override {
  return SRef.isAcceptableNestedNameSpecifier(candidate.getCorrectionDecl());
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return std::make_unique<NestedNameSpecifierValidatorCCC>(*this);
}

private:
Sema &SRef;
462};

464}

466/// Build a new nested-name-specifier for "identifier::", as described
467/// by ActOnCXXNestedNameSpecifier.
468///
469/// \param S Scope in which the nested-name-specifier occurs.
470/// \param IdInfo Parser information about an identifier in the
471///        nested-name-spec.
472/// \param EnteringContext If true, enter the context specified by the
473///        nested-name-specifier.
474/// \param SS Optional nested name specifier preceding the identifier.
475/// \param ScopeLookupResult Provides the result of name lookup within the
476///        scope of the nested-name-specifier that was computed at template
477///        definition time.
478/// \param ErrorRecoveryLookup Specifies if the method is called to improve
479///        error recovery and what kind of recovery is performed.
480/// \param IsCorrectedToColon If not null, suggestion of replace '::' -> ':'
481///        are allowed.  The bool value pointed by this parameter is set to
482///       'true' if the identifier is treated as if it was followed by ':',
483///        not '::'.
484/// \param OnlyNamespace If true, only considers namespaces in lookup.
485///
486/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
487/// that it contains an extra parameter \p ScopeLookupResult, which provides
488/// the result of name lookup within the scope of the nested-name-specifier
489/// that was computed at template definition time.
490///
491/// If ErrorRecoveryLookup is true, then this call is used to improve error
492/// recovery.  This means that it should not emit diagnostics, it should
493/// just return true on failure.  It also means it should only return a valid
494/// scope if it *knows* that the result is correct.  It should not return in a
495/// dependent context, for example. Nor will it extend \p SS with the scope
496/// specifier.
497bool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
                                     bool EnteringContext, CXXScopeSpec &SS,
                                     NamedDecl *ScopeLookupResult,
                                     bool ErrorRecoveryLookup,
                                     bool *IsCorrectedToColon,
                                     bool OnlyNamespace) {
if (IdInfo.Identifier->isEditorPlaceholder())
  return true;
LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
                   OnlyNamespace ? LookupNamespaceName
                                 : LookupNestedNameSpecifierName);
QualType ObjectType = GetTypeFromParser(IdInfo.ObjectType);

// Determine where to perform name lookup
DeclContext *LookupCtx = nullptr;
bool isDependent = false;
if (IsCorrectedToColon)
  *IsCorrectedToColon = false;
if (!ObjectType.isNull()) {
  // This nested-name-specifier occurs in a member access expression, e.g.,
  // x->B::f, and we are looking into the type of the object.
  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist")((void)0);
  LookupCtx = computeDeclContext(ObjectType);
  isDependent = ObjectType->isDependentType();
} else if (SS.isSet()) {
  // This nested-name-specifier occurs after another nested-name-specifier,
  // so look into the context associated with the prior nested-name-specifier.
  LookupCtx = computeDeclContext(SS, EnteringContext);
  isDependent = isDependentScopeSpecifier(SS);
  Found.setContextRange(SS.getRange());
}

bool ObjectTypeSearchedInScope = false;
if (LookupCtx) {
  // Perform "qualified" name lookup into the declaration context we
  // computed, which is either the type of the base of a member access
  // expression or the declaration context associated with a prior
  // nested-name-specifier.

  // The declaration context must be complete.
  if (!LookupCtx->isDependentContext() &&
      RequireCompleteDeclContext(SS, LookupCtx))
    return true;

  LookupQualifiedName(Found, LookupCtx);

  if (!ObjectType.isNull() && Found.empty()) {
    // C++ [basic.lookup.classref]p4:
    //   If the id-expression in a class member access is a qualified-id of
    //   the form
    //
    //        class-name-or-namespace-name::...
    //
    //   the class-name-or-namespace-name following the . or -> operator is
    //   looked up both in the context of the entire postfix-expression and in
    //   the scope of the class of the object expression. If the name is found
    //   only in the scope of the class of the object expression, the name
    //   shall refer to a class-name. If the name is found only in the
    //   context of the entire postfix-expression, the name shall refer to a
    //   class-name or namespace-name. [...]
    //
    // Qualified name lookup into a class will not find a namespace-name,
    // so we do not need to diagnose that case specifically. However,
    // this qualified name lookup may find nothing. In that case, perform
    // unqualified name lookup in the given scope (if available) or
    // reconstruct the result from when name lookup was performed at template
    // definition time.
    if (S)
      LookupName(Found, S);
    else if (ScopeLookupResult)
      Found.addDecl(ScopeLookupResult);

    ObjectTypeSearchedInScope = true;
  }
} else if (!isDependent) {
  // Perform unqualified name lookup in the current scope.
  LookupName(Found, S);
}

if (Found.isAmbiguous())
  return true;

// If we performed lookup into a dependent context and did not find anything,
// that's fine: just build a dependent nested-name-specifier.
if (Found.empty() && isDependent &&
    !(LookupCtx && LookupCtx->isRecord() &&
      (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
       !cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
  // Don't speculate if we're just trying to improve error recovery.
  if (ErrorRecoveryLookup)
    return true;

  // We were not able to compute the declaration context for a dependent
  // base object type or prior nested-name-specifier, so this
  // nested-name-specifier refers to an unknown specialization. Just build
  // a dependent nested-name-specifier.
  SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc, IdInfo.CCLoc);
  return false;
}

if (Found.empty() && !ErrorRecoveryLookup) {
  // If identifier is not found as class-name-or-namespace-name, but is found
  // as other entity, don't look for typos.
  LookupResult R(*this, Found.getLookupNameInfo(), LookupOrdinaryName);
  if (LookupCtx)
    LookupQualifiedName(R, LookupCtx);
  else if (S && !isDependent)
    LookupName(R, S);
  if (!R.empty()) {
    // Don't diagnose problems with this speculative lookup.
    R.suppressDiagnostics();
    // The identifier is found in ordinary lookup. If correction to colon is
    // allowed, suggest replacement to ':'.
    if (IsCorrectedToColon) {
      *IsCorrectedToColon = true;
      Diag(IdInfo.CCLoc, diag::err_nested_name_spec_is_not_class)
          << IdInfo.Identifier << getLangOpts().CPlusPlus
          << FixItHint::CreateReplacement(IdInfo.CCLoc, ":");
      if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
        Diag(ND->getLocation(), diag::note_declared_at);
      return true;
    }
    // Replacement '::' -> ':' is not allowed, just issue respective error.
    Diag(R.getNameLoc(), OnlyNamespace
                             ? unsigned(diag::err_expected_namespace_name)
                             : unsigned(diag::err_expected_class_or_namespace))
        << IdInfo.Identifier << getLangOpts().CPlusPlus;
    if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
      Diag(ND->getLocation(), diag::note_entity_declared_at)
          << IdInfo.Identifier;
    return true;
  }
}

if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
  // We haven't found anything, and we're not recovering from a
  // different kind of error, so look for typos.
  DeclarationName Name = Found.getLookupName();
  Found.clear();
  NestedNameSpecifierValidatorCCC CCC(*this);
  if (TypoCorrection Corrected = CorrectTypo(
          Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS, CCC,
          CTK_ErrorRecovery, LookupCtx, EnteringContext)) {
    if (LookupCtx) {
      bool DroppedSpecifier =
          Corrected.WillReplaceSpecifier() &&
          Name.getAsString() == Corrected.getAsString(getLangOpts());
      if (DroppedSpecifier)
        SS.clear();
      diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
                                << Name << LookupCtx << DroppedSpecifier
                                << SS.getRange());
    } else
      diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
                                << Name);

    if (Corrected.getCorrectionSpecifier())
      SS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
                     SourceRange(Found.getNameLoc()));

    if (NamedDecl *ND = Corrected.getFoundDecl())
      Found.addDecl(ND);
    Found.setLookupName(Corrected.getCorrection());
  } else {
    Found.setLookupName(IdInfo.Identifier);
  }
}

NamedDecl *SD =
    Found.isSingleResult() ? Found.getRepresentativeDecl() : nullptr;
bool IsExtension = false;
bool AcceptSpec = isAcceptableNestedNameSpecifier(SD, &IsExtension);
if (!AcceptSpec && IsExtension) {
  AcceptSpec = true;
  Diag(IdInfo.IdentifierLoc, diag::ext_nested_name_spec_is_enum);
}
if (AcceptSpec) {
  if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
      !getLangOpts().CPlusPlus11) {
    // C++03 [basic.lookup.classref]p4:
    //   [...] If the name is found in both contexts, the
    //   class-name-or-namespace-name shall refer to the same entity.
    //
    // We already found the name in the scope of the object. Now, look
    // into the current scope (the scope of the postfix-expression) to
    // see if we can find the same name there. As above, if there is no
    // scope, reconstruct the result from the template instantiation itself.
    //
    // Note that C++11 does *not* perform this redundant lookup.
    NamedDecl *OuterDecl;
    if (S) {
      LookupResult FoundOuter(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
                              LookupNestedNameSpecifierName);
      LookupName(FoundOuter, S);
      OuterDecl = FoundOuter.getAsSingle<NamedDecl>();
    } else
      OuterDecl = ScopeLookupResult;

    if (isAcceptableNestedNameSpecifier(OuterDecl) &&
        OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
        (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
         !Context.hasSameType(
                          Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
                             Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
      if (ErrorRecoveryLookup)
        return true;

       Diag(IdInfo.IdentifierLoc,
            diag::err_nested_name_member_ref_lookup_ambiguous)
         << IdInfo.Identifier;
       Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
         << ObjectType;
       Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);

       // Fall through so that we'll pick the name we found in the object
       // type, since that's probably what the user wanted anyway.
     }
  }

  if (auto *TD = dyn_cast_or_null<TypedefNameDecl>(SD))
    MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);

  // If we're just performing this lookup for error-recovery purposes,
  // don't extend the nested-name-specifier. Just return now.
  if (ErrorRecoveryLookup)
    return false;

  // The use of a nested name specifier may trigger deprecation warnings.
  DiagnoseUseOfDecl(SD, IdInfo.CCLoc);

  if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
    SS.Extend(Context, Namespace, IdInfo.IdentifierLoc, IdInfo.CCLoc);
    return false;
  }

  if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
    SS.Extend(Context, Alias, IdInfo.IdentifierLoc, IdInfo.CCLoc);
    return false;
  }

  QualType T =
      Context.getTypeDeclType(cast<TypeDecl>(SD->getUnderlyingDecl()));
  TypeLocBuilder TLB;
  if (isa<InjectedClassNameType>(T)) {
    InjectedClassNameTypeLoc InjectedTL
      = TLB.push<InjectedClassNameTypeLoc>(T);
    InjectedTL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<RecordType>(T)) {
    RecordTypeLoc RecordTL = TLB.push<RecordTypeLoc>(T);
    RecordTL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<TypedefType>(T)) {
    TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(T);
    TypedefTL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<EnumType>(T)) {
    EnumTypeLoc EnumTL = TLB.push<EnumTypeLoc>(T);
    EnumTL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<TemplateTypeParmType>(T)) {
    TemplateTypeParmTypeLoc TemplateTypeTL
      = TLB.push<TemplateTypeParmTypeLoc>(T);
    TemplateTypeTL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<UnresolvedUsingType>(T)) {
    UnresolvedUsingTypeLoc UnresolvedTL
      = TLB.push<UnresolvedUsingTypeLoc>(T);
    UnresolvedTL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<SubstTemplateTypeParmType>(T)) {
    SubstTemplateTypeParmTypeLoc TL
      = TLB.push<SubstTemplateTypeParmTypeLoc>(T);
    TL.setNameLoc(IdInfo.IdentifierLoc);
  } else if (isa<SubstTemplateTypeParmPackType>(T)) {
    SubstTemplateTypeParmPackTypeLoc TL
      = TLB.push<SubstTemplateTypeParmPackTypeLoc>(T);
    TL.setNameLoc(IdInfo.IdentifierLoc);
  } else {
    llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier")__builtin_unreachable();
  }

  if (T->isEnumeralType())
    Diag(IdInfo.IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);

  SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
            IdInfo.CCLoc);
  return false;
}

// Otherwise, we have an error case.  If we don't want diagnostics, just
// return an error now.
if (ErrorRecoveryLookup)
  return true;

// If we didn't find anything during our lookup, try again with
// ordinary name lookup, which can help us produce better error
// messages.
if (Found.empty()) {
  Found.clear(LookupOrdinaryName);
  LookupName(Found, S);
}

// In Microsoft mode, if we are within a templated function and we can't
// resolve Identifier, then extend the SS with Identifier. This will have
// the effect of resolving Identifier during template instantiation.
// The goal is to be able to resolve a function call whose
// nested-name-specifier is located inside a dependent base class.
// Example:
//
// class C {
// public:
//    static void foo2() {  }
// };
// template <class T> class A { public: typedef C D; };
//
// template <class T> class B : public A<T> {
// public:
//   void foo() { D::foo2(); }
// };
if (getLangOpts().MSVCCompat) {
  DeclContext *DC = LookupCtx ? LookupCtx : CurContext;
  if (DC->isDependentContext() && DC->isFunctionOrMethod()) {
    CXXRecordDecl *ContainingClass = dyn_cast<CXXRecordDecl>(DC->getParent());
    if (ContainingClass && ContainingClass->hasAnyDependentBases()) {
      Diag(IdInfo.IdentifierLoc,
           diag::ext_undeclared_unqual_id_with_dependent_base)
          << IdInfo.Identifier << ContainingClass;
      SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc,
                IdInfo.CCLoc);
      return false;
    }
  }
}

if (!Found.empty()) {
  if (TypeDecl *TD = Found.getAsSingle<TypeDecl>())
    Diag(IdInfo.IdentifierLoc, diag::err_expected_class_or_namespace)
        << Context.getTypeDeclType(TD) << getLangOpts().CPlusPlus;
  else {
    Diag(IdInfo.IdentifierLoc, diag::err_expected_class_or_namespace)
        << IdInfo.Identifier << getLangOpts().CPlusPlus;
    if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
      Diag(ND->getLocation(), diag::note_entity_declared_at)
          << IdInfo.Identifier;
  }
} else if (SS.isSet())
  Diag(IdInfo.IdentifierLoc, diag::err_no_member) << IdInfo.Identifier
      << LookupCtx << SS.getRange();
else
  Diag(IdInfo.IdentifierLoc, diag::err_undeclared_var_use)
      << IdInfo.Identifier;

return true;
845}

847bool Sema::ActOnCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
                                     bool EnteringContext, CXXScopeSpec &SS,
                                     bool ErrorRecoveryLookup,
                                     bool *IsCorrectedToColon,
                                     bool OnlyNamespace) {
if (SS.isInvalid())
  return true;

return BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
                                   /*ScopeLookupResult=*/nullptr, false,
                                   IsCorrectedToColon, OnlyNamespace);
858}

860bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
                                             const DeclSpec &DS,
                                             SourceLocation ColonColonLoc) {
if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
  return true;

assert(DS.getTypeSpecType() == DeclSpec::TST_decltype)((void)0);

QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
if (T.isNull())
  return true;

if (!T->isDependentType() && !T->getAs<TagType>()) {
  Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
    << T << getLangOpts().CPlusPlus;
  return true;
}

TypeLocBuilder TLB;
DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
          ColonColonLoc);
return false;
884}

886/// IsInvalidUnlessNestedName - This method is used for error recovery
887/// purposes to determine whether the specified identifier is only valid as
888/// a nested name specifier, for example a namespace name.  It is
889/// conservatively correct to always return false from this method.
890///
891/// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
892bool Sema::IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
                                   NestedNameSpecInfo &IdInfo,
                                   bool EnteringContext) {
if (SS.isInvalid())
  return false;

return !BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
                                    /*ScopeLookupResult=*/nullptr, true);
900}

902bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
                                     CXXScopeSpec &SS,
                                     SourceLocation TemplateKWLoc,
                                     TemplateTy OpaqueTemplate,
                                     SourceLocation TemplateNameLoc,
                                     SourceLocation LAngleLoc,
                                     ASTTemplateArgsPtr TemplateArgsIn,
                                     SourceLocation RAngleLoc,
                                     SourceLocation CCLoc,
                                     bool EnteringContext) {
if (SS.isInvalid())
  return true;

TemplateName Template = OpaqueTemplate.get();

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
translateTemplateArguments(TemplateArgsIn, TemplateArgs);

DependentTemplateName *DTN = Template.getAsDependentTemplateName();
if (DTN && DTN->isIdentifier()) {
  // Handle a dependent template specialization for which we cannot resolve
  // the template name.
  assert(DTN->getQualifier() == SS.getScopeRep())((void)0);
  QualType T = Context.getDependentTemplateSpecializationType(ETK_None,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                              TemplateArgs);

  // Create source-location information for this type.
  TypeLocBuilder Builder;
  DependentTemplateSpecializationTypeLoc SpecTL
    = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(SourceLocation());
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateNameLoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());

  SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
            CCLoc);
  return false;
}

// If we assumed an undeclared identifier was a template name, try to
// typo-correct it now.
if (Template.getAsAssumedTemplateName() &&
    resolveAssumedTemplateNameAsType(S, Template, TemplateNameLoc))
  return true;

TemplateDecl *TD = Template.getAsTemplateDecl();
if (Template.getAsOverloadedTemplate() || DTN ||
    isa<FunctionTemplateDecl>(TD) || isa<VarTemplateDecl>(TD)) {
  SourceRange R(TemplateNameLoc, RAngleLoc);
  if (SS.getRange().isValid())
    R.setBegin(SS.getRange().getBegin());

  Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier)
    << (TD && isa<VarTemplateDecl>(TD)) << Template << R;
  NoteAllFoundTemplates(Template);
  return true;
}

// We were able to resolve the template name to an actual template.
// Build an appropriate nested-name-specifier.
QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
if (T.isNull())
  return true;

// Alias template specializations can produce types which are not valid
// nested name specifiers.
if (!T->isDependentType() && !T->getAs<TagType>()) {
  Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
  NoteAllFoundTemplates(Template);
  return true;
}

// Provide source-location information for the template specialization type.
TypeLocBuilder Builder;
TemplateSpecializationTypeLoc SpecTL
  = Builder.push<TemplateSpecializationTypeLoc>(T);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateNameLoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());


SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
          CCLoc);
return false;
997}

999namespace {
/// A structure that stores a nested-name-specifier annotation,
/// including both the nested-name-specifier
struct NestedNameSpecifierAnnotation {
  NestedNameSpecifier *NNS;
};
1005}

1007void *Sema::SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS) {
if (SS.isEmpty() || SS.isInvalid())
  return nullptr;

void *Mem = Context.Allocate(
    (sizeof(NestedNameSpecifierAnnotation) + SS.location_size()),
    alignof(NestedNameSpecifierAnnotation));
NestedNameSpecifierAnnotation *Annotation
  = new (Mem) NestedNameSpecifierAnnotation;
Annotation->NNS = SS.getScopeRep();
memcpy(Annotation + 1, SS.location_data(), SS.location_size());
return Annotation;
1019}

1021void Sema::RestoreNestedNameSpecifierAnnotation(void *AnnotationPtr,
                                              SourceRange AnnotationRange,
                                              CXXScopeSpec &SS) {
if (!AnnotationPtr) {
  SS.SetInvalid(AnnotationRange);
  return;
}

NestedNameSpecifierAnnotation *Annotation
  = static_cast<NestedNameSpecifierAnnotation *>(AnnotationPtr);
SS.Adopt(NestedNameSpecifierLoc(Annotation->NNS, Annotation + 1));
1032}

1034bool Sema::ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.")((void)0);

// Don't enter a declarator context when the current context is an Objective-C
// declaration.
if (isa<ObjCContainerDecl>(CurContext) || isa<ObjCMethodDecl>(CurContext))
  return false;

NestedNameSpecifier *Qualifier = SS.getScopeRep();

// There are only two places a well-formed program may qualify a
// declarator: first, when defining a namespace or class member
// out-of-line, and second, when naming an explicitly-qualified
// friend function.  The latter case is governed by
// C++03 [basic.lookup.unqual]p10:
//   In a friend declaration naming a member function, a name used
//   in the function declarator and not part of a template-argument
//   in a template-id is first looked up in the scope of the member
//   function's class. If it is not found, or if the name is part of
//   a template-argument in a template-id, the look up is as
//   described for unqualified names in the definition of the class
//   granting friendship.
// i.e. we don't push a scope unless it's a class member.

switch (Qualifier->getKind()) {
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
  // These are always namespace scopes.  We never want to enter a
  // namespace scope from anything but a file context.
  return CurContext->getRedeclContext()->isFileContext();

case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
case NestedNameSpecifier::Super:
  // These are never namespace scopes.
  return true;
}

llvm_unreachable("Invalid NestedNameSpecifier::Kind!")__builtin_unreachable();
1075}

1077/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1078/// scope or nested-name-specifier) is parsed, part of a declarator-id.
1079/// After this method is called, according to [C++ 3.4.3p3], names should be
1080/// looked up in the declarator-id's scope, until the declarator is parsed and
1081/// ActOnCXXExitDeclaratorScope is called.
1082/// The 'SS' should be a non-empty valid CXXScopeSpec.
1083bool Sema::ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) {
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.")((void)0);

if (SS.isInvalid()) return true;
1
Taking false branch→

DeclContext *DC = computeDeclContext(SS, true);
2
←
Calling 'Sema::computeDeclContext'→
if (!DC) return true;

// Before we enter a declarator's context, we need to make sure that
// it is a complete declaration context.
if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC))
  return true;

EnterDeclaratorContext(S, DC);

// Rebuild the nested name specifier for the new scope.
if (DC->isDependentContext())
  RebuildNestedNameSpecifierInCurrentInstantiation(SS);

return false;
1103}

1105/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1106/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1107/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1108/// Used to indicate that names should revert to being looked up in the
1109/// defining scope.
1110void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.")((void)0);
if (SS.isInvalid())
  return;
assert(!SS.isInvalid() && computeDeclContext(SS, true) &&((void)0)
       "exiting declarator scope we never really entered")((void)0);
ExitDeclaratorContext(S);
1117}

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/Sema/DeclSpec.h

1//===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file defines the classes used to store parsed information about
11/// declaration-specifiers and declarators.
12///
13/// \verbatim
14///   static const int volatile x, *y, *(*(*z)[10])(const void *x);
15///   ------------------------- -  --  ---------------------------
16///     declaration-specifiers  \  |   /
17///                            declarators
18/// \endverbatim
19///
20//===----------------------------------------------------------------------===//

22#ifndef LLVM_CLANG_SEMA_DECLSPEC_H
23#define LLVM_CLANG_SEMA_DECLSPEC_H

25#include "clang/AST/DeclCXX.h"
26#include "clang/AST/DeclObjCCommon.h"
27#include "clang/AST/NestedNameSpecifier.h"
28#include "clang/Basic/ExceptionSpecificationType.h"
29#include "clang/Basic/Lambda.h"
30#include "clang/Basic/OperatorKinds.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Lex/Token.h"
33#include "clang/Sema/Ownership.h"
34#include "clang/Sema/ParsedAttr.h"
35#include "llvm/ADT/SmallVector.h"
36#include "llvm/Support/Compiler.h"
37#include "llvm/Support/ErrorHandling.h"

39namespace clang {
class ASTContext;
class CXXRecordDecl;
class TypeLoc;
class LangOptions;
class IdentifierInfo;
class NamespaceAliasDecl;
class NamespaceDecl;
class ObjCDeclSpec;
class Sema;
class Declarator;
struct TemplateIdAnnotation;

52/// Represents a C++ nested-name-specifier or a global scope specifier.
53///
54/// These can be in 3 states:
55///   1) Not present, identified by isEmpty()
56///   2) Present, identified by isNotEmpty()
57///      2.a) Valid, identified by isValid()
58///      2.b) Invalid, identified by isInvalid().
59///
60/// isSet() is deprecated because it mostly corresponded to "valid" but was
61/// often used as if it meant "present".
62///
63/// The actual scope is described by getScopeRep().
64class CXXScopeSpec {
SourceRange Range;
NestedNameSpecifierLocBuilder Builder;

68public:
SourceRange getRange() const { return Range; }
void setRange(SourceRange R) { Range = R; }
void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); }
void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); }
SourceLocation getBeginLoc() const { return Range.getBegin(); }
SourceLocation getEndLoc() const { return Range.getEnd(); }

/// Retrieve the representation of the nested-name-specifier.
NestedNameSpecifier *getScopeRep() const {
  return Builder.getRepresentation();
}

/// Extend the current nested-name-specifier by another
/// nested-name-specifier component of the form 'type::'.
///
/// \param Context The AST context in which this nested-name-specifier
/// resides.
///
/// \param TemplateKWLoc The location of the 'template' keyword, if present.
///
/// \param TL The TypeLoc that describes the type preceding the '::'.
///
/// \param ColonColonLoc The location of the trailing '::'.
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL,
            SourceLocation ColonColonLoc);

/// Extend the current nested-name-specifier by another
/// nested-name-specifier component of the form 'identifier::'.
///
/// \param Context The AST context in which this nested-name-specifier
/// resides.
///
/// \param Identifier The identifier.
///
/// \param IdentifierLoc The location of the identifier.
///
/// \param ColonColonLoc The location of the trailing '::'.
void Extend(ASTContext &Context, IdentifierInfo *Identifier,
            SourceLocation IdentifierLoc, SourceLocation ColonColonLoc);

/// Extend the current nested-name-specifier by another
/// nested-name-specifier component of the form 'namespace::'.
///
/// \param Context The AST context in which this nested-name-specifier
/// resides.
///
/// \param Namespace The namespace.
///
/// \param NamespaceLoc The location of the namespace name.
///
/// \param ColonColonLoc The location of the trailing '::'.
void Extend(ASTContext &Context, NamespaceDecl *Namespace,
            SourceLocation NamespaceLoc, SourceLocation ColonColonLoc);

/// Extend the current nested-name-specifier by another
/// nested-name-specifier component of the form 'namespace-alias::'.
///
/// \param Context The AST context in which this nested-name-specifier
/// resides.
///
/// \param Alias The namespace alias.
///
/// \param AliasLoc The location of the namespace alias
/// name.
///
/// \param ColonColonLoc The location of the trailing '::'.
void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
            SourceLocation AliasLoc, SourceLocation ColonColonLoc);

/// Turn this (empty) nested-name-specifier into the global
/// nested-name-specifier '::'.
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);

/// Turns this (empty) nested-name-specifier into '__super'
/// nested-name-specifier.
///
/// \param Context The AST context in which this nested-name-specifier
/// resides.
///
/// \param RD The declaration of the class in which nested-name-specifier
/// appeared.
///
/// \param SuperLoc The location of the '__super' keyword.
/// name.
///
/// \param ColonColonLoc The location of the trailing '::'.
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
               SourceLocation SuperLoc, SourceLocation ColonColonLoc);

/// Make a new nested-name-specifier from incomplete source-location
/// information.
///
/// FIXME: This routine should be used very, very rarely, in cases where we
/// need to synthesize a nested-name-specifier. Most code should instead use
/// \c Adopt() with a proper \c NestedNameSpecifierLoc.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,
                 SourceRange R);

/// Adopt an existing nested-name-specifier (with source-range
/// information).
void Adopt(NestedNameSpecifierLoc Other);

/// Retrieve a nested-name-specifier with location information, copied
/// into the given AST context.
///
/// \param Context The context into which this nested-name-specifier will be
/// copied.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const;

/// Retrieve the location of the name in the last qualifier
/// in this nested name specifier.
///
/// For example, the location of \c bar
/// in
/// \verbatim
///   \::foo::bar<0>::
///           ^~~
/// \endverbatim
SourceLocation getLastQualifierNameLoc() const;

/// No scope specifier.
bool isEmpty() const { return Range.isInvalid() && getScopeRep() == nullptr; }
/// A scope specifier is present, but may be valid or invalid.
bool isNotEmpty() const { return !isEmpty(); }

/// An error occurred during parsing of the scope specifier.
bool isInvalid() const { return Range.isValid() && getScopeRep() == nullptr; }
8
←
Returning zero, which participates in a condition later→
/// A scope specifier is present, and it refers to a real scope.
bool isValid() const { return getScopeRep() != nullptr; }

/// Indicate that this nested-name-specifier is invalid.
void SetInvalid(SourceRange R) {
  assert(R.isValid() && "Must have a valid source range")((void)0);
  if (Range.getBegin().isInvalid())
    Range.setBegin(R.getBegin());
  Range.setEnd(R.getEnd());
  Builder.Clear();
}

/// Deprecated.  Some call sites intend isNotEmpty() while others intend
/// isValid().
bool isSet() const { return getScopeRep() != nullptr; }
4
←
Assuming the condition is true→
5
←
Returning the value 1, which participates in a condition later→

void clear() {
  Range = SourceRange();
  Builder.Clear();
}

/// Retrieve the data associated with the source-location information.
char *location_data() const { return Builder.getBuffer().first; }

/// Retrieve the size of the data associated with source-location
/// information.
unsigned location_size() const { return Builder.getBuffer().second; }
223};

225/// Captures information about "declaration specifiers".
226///
227/// "Declaration specifiers" encompasses storage-class-specifiers,
228/// type-specifiers, type-qualifiers, and function-specifiers.
229class DeclSpec {
230public:
/// storage-class-specifier
/// \note The order of these enumerators is important for diagnostics.
enum SCS {
  SCS_unspecified = 0,
  SCS_typedef,
  SCS_extern,
  SCS_static,
  SCS_auto,
  SCS_register,
  SCS_private_extern,
  SCS_mutable
};

// Import thread storage class specifier enumeration and constants.
// These can be combined with SCS_extern and SCS_static.
typedef ThreadStorageClassSpecifier TSCS;
static const TSCS TSCS_unspecified = clang::TSCS_unspecified;
static const TSCS TSCS___thread = clang::TSCS___thread;
static const TSCS TSCS_thread_local = clang::TSCS_thread_local;
static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local;

enum TSC {
  TSC_unspecified,
  TSC_imaginary,
  TSC_complex
};

// Import type specifier type enumeration and constants.
typedef TypeSpecifierType TST;
static const TST TST_unspecified = clang::TST_unspecified;
static const TST TST_void = clang::TST_void;
static const TST TST_char = clang::TST_char;
static const TST TST_wchar = clang::TST_wchar;
static const TST TST_char8 = clang::TST_char8;
static const TST TST_char16 = clang::TST_char16;
static const TST TST_char32 = clang::TST_char32;
static const TST TST_int = clang::TST_int;
static const TST TST_int128 = clang::TST_int128;
static const TST TST_extint = clang::TST_extint;
static const TST TST_half = clang::TST_half;
static const TST TST_BFloat16 = clang::TST_BFloat16;
static const TST TST_float = clang::TST_float;
static const TST TST_double = clang::TST_double;
static const TST TST_float16 = clang::TST_Float16;
static const TST TST_accum = clang::TST_Accum;
static const TST TST_fract = clang::TST_Fract;
static const TST TST_float128 = clang::TST_float128;
static const TST TST_bool = clang::TST_bool;
static const TST TST_decimal32 = clang::TST_decimal32;
static const TST TST_decimal64 = clang::TST_decimal64;
static const TST TST_decimal128 = clang::TST_decimal128;
static const TST TST_enum = clang::TST_enum;
static const TST TST_union = clang::TST_union;
static const TST TST_struct = clang::TST_struct;
static const TST TST_interface = clang::TST_interface;
static const TST TST_class = clang::TST_class;
static const TST TST_typename = clang::TST_typename;
static const TST TST_typeofType = clang::TST_typeofType;
static const TST TST_typeofExpr = clang::TST_typeofExpr;
static const TST TST_decltype = clang::TST_decltype;
static const TST TST_decltype_auto = clang::TST_decltype_auto;
static const TST TST_underlyingType = clang::TST_underlyingType;
static const TST TST_auto = clang::TST_auto;
static const TST TST_auto_type = clang::TST_auto_type;
static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
static const TST TST_atomic = clang::TST_atomic;
297#define GENERIC_IMAGE_TYPE(ImgType, Id) \
static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
299#include "clang/Basic/OpenCLImageTypes.def"
static const TST TST_error = clang::TST_error;

// type-qualifiers
enum TQ {   // NOTE: These flags must be kept in sync with Qualifiers::TQ.
  TQ_unspecified = 0,
  TQ_const       = 1,
  TQ_restrict    = 2,
  TQ_volatile    = 4,
  TQ_unaligned   = 8,
  // This has no corresponding Qualifiers::TQ value, because it's not treated
  // as a qualifier in our type system.
  TQ_atomic      = 16
};

/// ParsedSpecifiers - Flags to query which specifiers were applied.  This is
/// returned by getParsedSpecifiers.
enum ParsedSpecifiers {
  PQ_None                  = 0,
  PQ_StorageClassSpecifier = 1,
  PQ_TypeSpecifier         = 2,
  PQ_TypeQualifier         = 4,
  PQ_FunctionSpecifier     = 8
  // FIXME: Attributes should be included here.
};

325private:
// storage-class-specifier
/*SCS*/unsigned StorageClassSpec : 3;
/*TSCS*/unsigned ThreadStorageClassSpec : 2;
unsigned SCS_extern_in_linkage_spec : 1;

// type-specifier
/*TypeSpecifierWidth*/ unsigned TypeSpecWidth : 2;
/*TSC*/unsigned TypeSpecComplex : 2;
/*TSS*/unsigned TypeSpecSign : 2;
/*TST*/unsigned TypeSpecType : 6;
unsigned TypeAltiVecVector : 1;
unsigned TypeAltiVecPixel : 1;
unsigned TypeAltiVecBool : 1;
unsigned TypeSpecOwned : 1;
unsigned TypeSpecPipe : 1;
unsigned TypeSpecSat : 1;
unsigned ConstrainedAuto : 1;

// type-qualifiers
unsigned TypeQualifiers : 5;  // Bitwise OR of TQ.

// function-specifier
unsigned FS_inline_specified : 1;
unsigned FS_forceinline_specified: 1;
unsigned FS_virtual_specified : 1;
unsigned FS_noreturn_specified : 1;

// friend-specifier
unsigned Friend_specified : 1;

// constexpr-specifier
unsigned ConstexprSpecifier : 2;

union {
  UnionParsedType TypeRep;
  Decl *DeclRep;
  Expr *ExprRep;
  TemplateIdAnnotation *TemplateIdRep;
};

/// ExplicitSpecifier - Store information about explicit spicifer.
ExplicitSpecifier FS_explicit_specifier;

// attributes.
ParsedAttributes Attrs;

// Scope specifier for the type spec, if applicable.
CXXScopeSpec TypeScope;

// SourceLocation info.  These are null if the item wasn't specified or if
// the setting was synthesized.
SourceRange Range;

SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
SourceRange TSWRange;
SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;
/// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
/// typename, then this is the location of the named type (if present);
/// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
/// TSTNameLoc provides source range info for tag types.
SourceLocation TSTNameLoc;
SourceRange TypeofParensRange;
SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
    TQ_unalignedLoc;
SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
SourceLocation FS_explicitCloseParenLoc;
SourceLocation FS_forceinlineLoc;
SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
SourceLocation TQ_pipeLoc;

WrittenBuiltinSpecs writtenBS;
void SaveWrittenBuiltinSpecs();

ObjCDeclSpec *ObjCQualifiers;

static bool isTypeRep(TST T) {
  return (T == TST_typename || T == TST_typeofType ||
          T == TST_underlyingType || T == TST_atomic);
}
static bool isExprRep(TST T) {
  return (T == TST_typeofExpr || T == TST_decltype || T == TST_extint);
}
static bool isTemplateIdRep(TST T) {
  return (T == TST_auto || T == TST_decltype_auto);
}

DeclSpec(const DeclSpec &) = delete;
void operator=(const DeclSpec &) = delete;
414public:
static bool isDeclRep(TST T) {
  return (T == TST_enum || T == TST_struct ||
          T == TST_interface || T == TST_union ||
          T == TST_class);
}

DeclSpec(AttributeFactory &attrFactory)
    : StorageClassSpec(SCS_unspecified),
      ThreadStorageClassSpec(TSCS_unspecified),
      SCS_extern_in_linkage_spec(false),
      TypeSpecWidth(static_cast<unsigned>(TypeSpecifierWidth::Unspecified)),
      TypeSpecComplex(TSC_unspecified),
      TypeSpecSign(static_cast<unsigned>(TypeSpecifierSign::Unspecified)),
      TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
      TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
      TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false),
      TypeQualifiers(TQ_unspecified), FS_inline_specified(false),
      FS_forceinline_specified(false), FS_virtual_specified(false),
      FS_noreturn_specified(false), Friend_specified(false),
      ConstexprSpecifier(
          static_cast<unsigned>(ConstexprSpecKind::Unspecified)),
      FS_explicit_specifier(), Attrs(attrFactory), writtenBS(),
      ObjCQualifiers(nullptr) {}

// storage-class-specifier
SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
TSCS getThreadStorageClassSpec() const {
  return (TSCS)ThreadStorageClassSpec;
}
bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
void setExternInLinkageSpec(bool Value) {
  SCS_extern_in_linkage_spec = Value;
}

SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; }
SourceLocation getThreadStorageClassSpecLoc() const {
  return ThreadStorageClassSpecLoc;
}

void ClearStorageClassSpecs() {
  StorageClassSpec           = DeclSpec::SCS_unspecified;
  ThreadStorageClassSpec     = DeclSpec::TSCS_unspecified;
  SCS_extern_in_linkage_spec = false;
  StorageClassSpecLoc        = SourceLocation();
  ThreadStorageClassSpecLoc  = SourceLocation();
}

void ClearTypeSpecType() {
  TypeSpecType = DeclSpec::TST_unspecified;
  TypeSpecOwned = false;
  TSTLoc = SourceLocation();
}

// type-specifier
TypeSpecifierWidth getTypeSpecWidth() const {
  return static_cast<TypeSpecifierWidth>(TypeSpecWidth);
}
TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; }
TypeSpecifierSign getTypeSpecSign() const {
  return static_cast<TypeSpecifierSign>(TypeSpecSign);
}
TST getTypeSpecType() const { return (TST)TypeSpecType; }
bool isTypeAltiVecVector() const { return TypeAltiVecVector; }
bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; }
bool isTypeAltiVecBool() const { return TypeAltiVecBool; }
bool isTypeSpecOwned() const { return TypeSpecOwned; }
bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }
bool isTypeSpecPipe() const { return TypeSpecPipe; }
bool isTypeSpecSat() const { return TypeSpecSat; }
bool isConstrainedAuto() const { return ConstrainedAuto; }

ParsedType getRepAsType() const {
  assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type")((void)0);
  return TypeRep;
}
Decl *getRepAsDecl() const {
  assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl")((void)0);
  return DeclRep;
}
Expr *getRepAsExpr() const {
  assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr")((void)0);
  return ExprRep;
}
TemplateIdAnnotation *getRepAsTemplateId() const {
  assert(isTemplateIdRep((TST) TypeSpecType) &&((void)0)
         "DeclSpec does not store a template id")((void)0);
  return TemplateIdRep;
}
CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }

SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }

SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }
SourceRange getTypeSpecWidthRange() const { return TSWRange; }
SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
SourceLocation getTypeSpecSatLoc() const { return TSSatLoc; }

SourceLocation getTypeSpecTypeNameLoc() const {
  assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename)((void)0);
  return TSTNameLoc;
}

SourceRange getTypeofParensRange() const { return TypeofParensRange; }
void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }

bool hasAutoTypeSpec() const {
  return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type ||
          TypeSpecType == TST_decltype_auto);
}

bool hasTagDefinition() const;

/// Turn a type-specifier-type into a string like "_Bool" or "union".
static const char *getSpecifierName(DeclSpec::TST T,
                                    const PrintingPolicy &Policy);
static const char *getSpecifierName(DeclSpec::TQ Q);
static const char *getSpecifierName(TypeSpecifierSign S);
static const char *getSpecifierName(DeclSpec::TSC C);
static const char *getSpecifierName(TypeSpecifierWidth W);
static const char *getSpecifierName(DeclSpec::SCS S);
static const char *getSpecifierName(DeclSpec::TSCS S);
static const char *getSpecifierName(ConstexprSpecKind C);

// type-qualifiers

/// getTypeQualifiers - Return a set of TQs.
unsigned getTypeQualifiers() const { return TypeQualifiers; }
SourceLocation getConstSpecLoc() const { return TQ_constLoc; }
SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; }
SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; }
SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; }
SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; }
SourceLocation getPipeLoc() const { return TQ_pipeLoc; }

/// Clear out all of the type qualifiers.
void ClearTypeQualifiers() {
  TypeQualifiers = 0;
  TQ_constLoc = SourceLocation();
  TQ_restrictLoc = SourceLocation();
  TQ_volatileLoc = SourceLocation();
  TQ_atomicLoc = SourceLocation();
  TQ_unalignedLoc = SourceLocation();
  TQ_pipeLoc = SourceLocation();
}

// function-specifier
bool isInlineSpecified() const {
  return FS_inline_specified | FS_forceinline_specified;
}
SourceLocation getInlineSpecLoc() const {
  return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
}

ExplicitSpecifier getExplicitSpecifier() const {
  return FS_explicit_specifier;
}

bool isVirtualSpecified() const { return FS_virtual_specified; }
SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }

bool hasExplicitSpecifier() const {
  return FS_explicit_specifier.isSpecified();
}
SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
SourceRange getExplicitSpecRange() const {
  return FS_explicit_specifier.getExpr()
             ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc)
             : SourceRange(FS_explicitLoc);
}

bool isNoreturnSpecified() const { return FS_noreturn_specified; }
SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }

void ClearFunctionSpecs() {
  FS_inline_specified = false;
  FS_inlineLoc = SourceLocation();
  FS_forceinline_specified = false;
  FS_forceinlineLoc = SourceLocation();
  FS_virtual_specified = false;
  FS_virtualLoc = SourceLocation();
  FS_explicit_specifier = ExplicitSpecifier();
  FS_explicitLoc = SourceLocation();
  FS_explicitCloseParenLoc = SourceLocation();
  FS_noreturn_specified = false;
  FS_noreturnLoc = SourceLocation();
}

/// This method calls the passed in handler on each CVRU qual being
/// set.
/// Handle - a handler to be invoked.
void forEachCVRUQualifier(
    llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);

/// This method calls the passed in handler on each qual being
/// set.
/// Handle - a handler to be invoked.
void forEachQualifier(
    llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle);

/// Return true if any type-specifier has been found.
bool hasTypeSpecifier() const {
  return getTypeSpecType() != DeclSpec::TST_unspecified ||
         getTypeSpecWidth() != TypeSpecifierWidth::Unspecified ||
         getTypeSpecComplex() != DeclSpec::TSC_unspecified ||
         getTypeSpecSign() != TypeSpecifierSign::Unspecified;
}

/// Return a bitmask of which flavors of specifiers this
/// DeclSpec includes.
unsigned getParsedSpecifiers() const;

/// isEmpty - Return true if this declaration specifier is completely empty:
/// no tokens were parsed in the production of it.
bool isEmpty() const {
  return getParsedSpecifiers() == DeclSpec::PQ_None;
}

void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); }
void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); }

/// These methods set the specified attribute of the DeclSpec and
/// return false if there was no error.  If an error occurs (for
/// example, if we tried to set "auto" on a spec with "extern"
/// already set), they return true and set PrevSpec and DiagID
/// such that
///   Diag(Loc, DiagID) << PrevSpec;
/// will yield a useful result.
///
/// TODO: use a more general approach that still allows these
/// diagnostics to be ignored when desired.
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
                         const char *&PrevSpec, unsigned &DiagID,
                         const PrintingPolicy &Policy);
bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
                               const char *&PrevSpec, unsigned &DiagID);
bool SetTypeSpecWidth(TypeSpecifierWidth W, SourceLocation Loc,
                      const char *&PrevSpec, unsigned &DiagID,
                      const PrintingPolicy &Policy);
bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
                        unsigned &DiagID);
bool SetTypeSpecSign(TypeSpecifierSign S, SourceLocation Loc,
                     const char *&PrevSpec, unsigned &DiagID);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
                     unsigned &DiagID, const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
                     unsigned &DiagID, ParsedType Rep,
                     const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
                     unsigned &DiagID, TypeResult Rep,
                     const PrintingPolicy &Policy) {
  if (Rep.isInvalid())
    return SetTypeSpecError();
  return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Rep.get(), Policy);
}
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
                     unsigned &DiagID, Decl *Rep, bool Owned,
                     const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
                     SourceLocation TagNameLoc, const char *&PrevSpec,
                     unsigned &DiagID, ParsedType Rep,
                     const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
                     SourceLocation TagNameLoc, const char *&PrevSpec,
                     unsigned &DiagID, Decl *Rep, bool Owned,
                     const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
                     unsigned &DiagID, TemplateIdAnnotation *Rep,
                     const PrintingPolicy &Policy);

bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
                     unsigned &DiagID, Expr *Rep,
                     const PrintingPolicy &policy);
bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
                     const char *&PrevSpec, unsigned &DiagID,
                     const PrintingPolicy &Policy);
bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
                     const char *&PrevSpec, unsigned &DiagID,
                     const PrintingPolicy &Policy);
bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
                     const char *&PrevSpec, unsigned &DiagID,
                     const PrintingPolicy &Policy);
bool SetTypePipe(bool isPipe, SourceLocation Loc,
                     const char *&PrevSpec, unsigned &DiagID,
                     const PrintingPolicy &Policy);
bool SetExtIntType(SourceLocation KWLoc, Expr *BitWidth,
                   const char *&PrevSpec, unsigned &DiagID,
                   const PrintingPolicy &Policy);
bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec,
                    unsigned &DiagID);
bool SetTypeSpecError();
void UpdateDeclRep(Decl *Rep) {
  assert(isDeclRep((TST) TypeSpecType))((void)0);
  DeclRep = Rep;
}
void UpdateTypeRep(ParsedType Rep) {
  assert(isTypeRep((TST) TypeSpecType))((void)0);
  TypeRep = Rep;
}
void UpdateExprRep(Expr *Rep) {
  assert(isExprRep((TST) TypeSpecType))((void)0);
  ExprRep = Rep;
}

bool SetTypeQual(TQ T, SourceLocation Loc);

bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
                 unsigned &DiagID, const LangOptions &Lang);

bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
                           unsigned &DiagID);
bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
                                unsigned &DiagID);
bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
                            unsigned &DiagID);
bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
                             unsigned &DiagID, ExplicitSpecifier ExplicitSpec,
                             SourceLocation CloseParenLoc);
bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
                             unsigned &DiagID);

bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
                   unsigned &DiagID);
bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
                          unsigned &DiagID);
bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc,
                      const char *&PrevSpec, unsigned &DiagID);

bool isFriendSpecified() const { return Friend_specified; }
SourceLocation getFriendSpecLoc() const { return FriendLoc; }

bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }

ConstexprSpecKind getConstexprSpecifier() const {
  return ConstexprSpecKind(ConstexprSpecifier);
}

SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
bool hasConstexprSpecifier() const {
  return getConstexprSpecifier() != ConstexprSpecKind::Unspecified;
}

void ClearConstexprSpec() {
  ConstexprSpecifier = static_cast<unsigned>(ConstexprSpecKind::Unspecified);
  ConstexprLoc = SourceLocation();
}

AttributePool &getAttributePool() const {
  return Attrs.getPool();
}

/// Concatenates two attribute lists.
///
/// The GCC attribute syntax allows for the following:
///
/// \code
/// short __attribute__(( unused, deprecated ))
/// int __attribute__(( may_alias, aligned(16) )) var;
/// \endcode
///
/// This declares 4 attributes using 2 lists. The following syntax is
/// also allowed and equivalent to the previous declaration.
///
/// \code
/// short __attribute__((unused)) __attribute__((deprecated))
/// int __attribute__((may_alias)) __attribute__((aligned(16))) var;
/// \endcode
///
void addAttributes(ParsedAttributesView &AL) {
  Attrs.addAll(AL.begin(), AL.end());
}

bool hasAttributes() const { return !Attrs.empty(); }

ParsedAttributes &getAttributes() { return Attrs; }
const ParsedAttributes &getAttributes() const { return Attrs; }

void takeAttributesFrom(ParsedAttributes &attrs) {
  Attrs.takeAllFrom(attrs);
}

/// Finish - This does final analysis of the declspec, issuing diagnostics for
/// things like "_Imaginary" (lacking an FP type).  After calling this method,
/// DeclSpec is guaranteed self-consistent, even if an error occurred.
void Finish(Sema &S, const PrintingPolicy &Policy);

const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
  return writtenBS;
}

ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; }
void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; }

/// Checks if this DeclSpec can stand alone, without a Declarator.
///
/// Only tag declspecs can stand alone.
bool isMissingDeclaratorOk();
818};

820/// Captures information about "declaration specifiers" specific to
821/// Objective-C.
822class ObjCDeclSpec {
823public:
/// ObjCDeclQualifier - Qualifier used on types in method
/// declarations.  Not all combinations are sensible.  Parameters
/// can be one of { in, out, inout } with one of { bycopy, byref }.
/// Returns can either be { oneway } or not.
///
/// This should be kept in sync with Decl::ObjCDeclQualifier.
enum ObjCDeclQualifier {
  DQ_None = 0x0,
  DQ_In = 0x1,
  DQ_Inout = 0x2,
  DQ_Out = 0x4,
  DQ_Bycopy = 0x8,
  DQ_Byref = 0x10,
  DQ_Oneway = 0x20,
  DQ_CSNullability = 0x40
};

ObjCDeclSpec()
    : objcDeclQualifier(DQ_None),
      PropertyAttributes(ObjCPropertyAttribute::kind_noattr), Nullability(0),
      GetterName(nullptr), SetterName(nullptr) {}

ObjCDeclQualifier getObjCDeclQualifier() const {
  return (ObjCDeclQualifier)objcDeclQualifier;
}
void setObjCDeclQualifier(ObjCDeclQualifier DQVal) {
  objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal);
}
void clearObjCDeclQualifier(ObjCDeclQualifier DQVal) {
  objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);
}

ObjCPropertyAttribute::Kind getPropertyAttributes() const {
  return ObjCPropertyAttribute::Kind(PropertyAttributes);
}
void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {
  PropertyAttributes =
      (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal);
}

NullabilityKind getNullability() const {
  assert(((void)0)
      ((getObjCDeclQualifier() & DQ_CSNullability) ||((void)0)
       (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&((void)0)
      "Objective-C declspec doesn't have nullability")((void)0);
  return static_cast<NullabilityKind>(Nullability);
}

SourceLocation getNullabilityLoc() const {
  assert(((void)0)
      ((getObjCDeclQualifier() & DQ_CSNullability) ||((void)0)
       (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&((void)0)
      "Objective-C declspec doesn't have nullability")((void)0);
  return NullabilityLoc;
}

void setNullability(SourceLocation loc, NullabilityKind kind) {
  assert(((void)0)
      ((getObjCDeclQualifier() & DQ_CSNullability) ||((void)0)
       (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) &&((void)0)
      "Set the nullability declspec or property attribute first")((void)0);
  Nullability = static_cast<unsigned>(kind);
  NullabilityLoc = loc;
}

const IdentifierInfo *getGetterName() const { return GetterName; }
IdentifierInfo *getGetterName() { return GetterName; }
SourceLocation getGetterNameLoc() const { return GetterNameLoc; }
void setGetterName(IdentifierInfo *name, SourceLocation loc) {
  GetterName = name;
  GetterNameLoc = loc;
}

const IdentifierInfo *getSetterName() const { return SetterName; }
IdentifierInfo *getSetterName() { return SetterName; }
SourceLocation getSetterNameLoc() const { return SetterNameLoc; }
void setSetterName(IdentifierInfo *name, SourceLocation loc) {
  SetterName = name;
  SetterNameLoc = loc;
}

905private:
// FIXME: These two are unrelated and mutually exclusive. So perhaps
// we can put them in a union to reflect their mutual exclusivity
// (space saving is negligible).
unsigned objcDeclQualifier : 7;

// NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttribute::Kind
unsigned PropertyAttributes : NumObjCPropertyAttrsBits;

unsigned Nullability : 2;

SourceLocation NullabilityLoc;

IdentifierInfo *GetterName;    // getter name or NULL if no getter
IdentifierInfo *SetterName;    // setter name or NULL if no setter
SourceLocation GetterNameLoc; // location of the getter attribute's value
SourceLocation SetterNameLoc; // location of the setter attribute's value

923};

925/// Describes the kind of unqualified-id parsed.
926enum class UnqualifiedIdKind {
/// An identifier.
IK_Identifier,
/// An overloaded operator name, e.g., operator+.
IK_OperatorFunctionId,
/// A conversion function name, e.g., operator int.
IK_ConversionFunctionId,
/// A user-defined literal name, e.g., operator "" _i.
IK_LiteralOperatorId,
/// A constructor name.
IK_ConstructorName,
/// A constructor named via a template-id.
IK_ConstructorTemplateId,
/// A destructor name.
IK_DestructorName,
/// A template-id, e.g., f<int>.
IK_TemplateId,
/// An implicit 'self' parameter
IK_ImplicitSelfParam,
/// A deduction-guide name (a template-name)
IK_DeductionGuideName
947};

949/// Represents a C++ unqualified-id that has been parsed.
950class UnqualifiedId {
951private:
UnqualifiedId(const UnqualifiedId &Other) = delete;
const UnqualifiedId &operator=(const UnqualifiedId &) = delete;

955public:
/// Describes the kind of unqualified-id parsed.
UnqualifiedIdKind Kind;

struct OFI {
  /// The kind of overloaded operator.
  OverloadedOperatorKind Operator;

  /// The source locations of the individual tokens that name
  /// the operator, e.g., the "new", "[", and "]" tokens in
  /// operator new [].
  ///
  /// Different operators have different numbers of tokens in their name,
  /// up to three. Any remaining source locations in this array will be
  /// set to an invalid value for operators with fewer than three tokens.
  SourceLocation SymbolLocations[3];
};

/// Anonymous union that holds extra data associated with the
/// parsed unqualified-id.
union {
  /// When Kind == IK_Identifier, the parsed identifier, or when
  /// Kind == IK_UserLiteralId, the identifier suffix.
  IdentifierInfo *Identifier;

  /// When Kind == IK_OperatorFunctionId, the overloaded operator
  /// that we parsed.
  struct OFI OperatorFunctionId;

  /// When Kind == IK_ConversionFunctionId, the type that the
  /// conversion function names.
  UnionParsedType ConversionFunctionId;

  /// When Kind == IK_ConstructorName, the class-name of the type
  /// whose constructor is being referenced.
  UnionParsedType ConstructorName;

  /// When Kind == IK_DestructorName, the type referred to by the
  /// class-name.
  UnionParsedType DestructorName;

  /// When Kind == IK_DeductionGuideName, the parsed template-name.
  UnionParsedTemplateTy TemplateName;

  /// When Kind == IK_TemplateId or IK_ConstructorTemplateId,
  /// the template-id annotation that contains the template name and
  /// template arguments.
  TemplateIdAnnotation *TemplateId;
};

/// The location of the first token that describes this unqualified-id,
/// which will be the location of the identifier, "operator" keyword,
/// tilde (for a destructor), or the template name of a template-id.
SourceLocation StartLocation;

/// The location of the last token that describes this unqualified-id.
SourceLocation EndLocation;

UnqualifiedId()
    : Kind(UnqualifiedIdKind::IK_Identifier), Identifier(nullptr) {}

/// Clear out this unqualified-id, setting it to default (invalid)
/// state.
void clear() {
  Kind = UnqualifiedIdKind::IK_Identifier;
  Identifier = nullptr;
  StartLocation = SourceLocation();
  EndLocation = SourceLocation();
}

/// Determine whether this unqualified-id refers to a valid name.
bool isValid() const { return StartLocation.isValid(); }

/// Determine whether this unqualified-id refers to an invalid name.
bool isInvalid() const { return !isValid(); }

/// Determine what kind of name we have.
UnqualifiedIdKind getKind() const { return Kind; }

/// Specify that this unqualified-id was parsed as an identifier.
///
/// \param Id the parsed identifier.
/// \param IdLoc the location of the parsed identifier.
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {
  Kind = UnqualifiedIdKind::IK_Identifier;
  Identifier = const_cast<IdentifierInfo *>(Id);
  StartLocation = EndLocation = IdLoc;
}

/// Specify that this unqualified-id was parsed as an
/// operator-function-id.
///
/// \param OperatorLoc the location of the 'operator' keyword.
///
/// \param Op the overloaded operator.
///
/// \param SymbolLocations the locations of the individual operator symbols
/// in the operator.
void setOperatorFunctionId(SourceLocation OperatorLoc,
                           OverloadedOperatorKind Op,
                           SourceLocation SymbolLocations[3]);

/// Specify that this unqualified-id was parsed as a
/// conversion-function-id.
///
/// \param OperatorLoc the location of the 'operator' keyword.
///
/// \param Ty the type to which this conversion function is converting.
///
/// \param EndLoc the location of the last token that makes up the type name.
void setConversionFunctionId(SourceLocation OperatorLoc,
                             ParsedType Ty,
                             SourceLocation EndLoc) {
  Kind = UnqualifiedIdKind::IK_ConversionFunctionId;
  StartLocation = OperatorLoc;
  EndLocation = EndLoc;
  ConversionFunctionId = Ty;
}

/// Specific that this unqualified-id was parsed as a
/// literal-operator-id.
///
/// \param Id the parsed identifier.
///
/// \param OpLoc the location of the 'operator' keyword.
///
/// \param IdLoc the location of the identifier.
void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc,
                            SourceLocation IdLoc) {
  Kind = UnqualifiedIdKind::IK_LiteralOperatorId;
  Identifier = const_cast<IdentifierInfo *>(Id);
  StartLocation = OpLoc;
  EndLocation = IdLoc;
}

/// Specify that this unqualified-id was parsed as a constructor name.
///
/// \param ClassType the class type referred to by the constructor name.
///
/// \param ClassNameLoc the location of the class name.
///
/// \param EndLoc the location of the last token that makes up the type name.
void setConstructorName(ParsedType ClassType,
                        SourceLocation ClassNameLoc,
                        SourceLocation EndLoc) {
  Kind = UnqualifiedIdKind::IK_ConstructorName;
  StartLocation = ClassNameLoc;
  EndLocation = EndLoc;
  ConstructorName = ClassType;
}

/// Specify that this unqualified-id was parsed as a
/// template-id that names a constructor.
///
/// \param TemplateId the template-id annotation that describes the parsed
/// template-id. This UnqualifiedId instance will take ownership of the
/// \p TemplateId and will free it on destruction.
void setConstructorTemplateId(TemplateIdAnnotation *TemplateId);

/// Specify that this unqualified-id was parsed as a destructor name.
///
/// \param TildeLoc the location of the '~' that introduces the destructor
/// name.
///
/// \param ClassType the name of the class referred to by the destructor name.
void setDestructorName(SourceLocation TildeLoc,
                       ParsedType ClassType,
                       SourceLocation EndLoc) {
  Kind = UnqualifiedIdKind::IK_DestructorName;
  StartLocation = TildeLoc;
  EndLocation = EndLoc;
  DestructorName = ClassType;
}

/// Specify that this unqualified-id was parsed as a template-id.
///
/// \param TemplateId the template-id annotation that describes the parsed
/// template-id. This UnqualifiedId instance will take ownership of the
/// \p TemplateId and will free it on destruction.
void setTemplateId(TemplateIdAnnotation *TemplateId);

/// Specify that this unqualified-id was parsed as a template-name for
/// a deduction-guide.
///
/// \param Template The parsed template-name.
/// \param TemplateLoc The location of the parsed template-name.
void setDeductionGuideName(ParsedTemplateTy Template,
                           SourceLocation TemplateLoc) {
  Kind = UnqualifiedIdKind::IK_DeductionGuideName;
  TemplateName = Template;
  StartLocation = EndLocation = TemplateLoc;
}

/// Specify that this unqualified-id is an implicit 'self'
/// parameter.
///
/// \param Id the identifier.
void setImplicitSelfParam(const IdentifierInfo *Id) {
  Kind = UnqualifiedIdKind::IK_ImplicitSelfParam;
  Identifier = const_cast<IdentifierInfo *>(Id);
  StartLocation = EndLocation = SourceLocation();
}

/// Return the source range that covers this unqualified-id.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(StartLocation, EndLocation);
}
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return StartLocation; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return EndLocation; }
1164};

1166/// A set of tokens that has been cached for later parsing.
1167typedef SmallVector<Token, 4> CachedTokens;

1169/// One instance of this struct is used for each type in a
1170/// declarator that is parsed.
1171///
1172/// This is intended to be a small value object.
1173struct DeclaratorChunk {
DeclaratorChunk() {};

enum {
  Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren, Pipe
} Kind;

/// Loc - The place where this type was defined.
SourceLocation Loc;
/// EndLoc - If valid, the place where this chunck ends.
SourceLocation EndLoc;

SourceRange getSourceRange() const {
  if (EndLoc.isInvalid())
    return SourceRange(Loc, Loc);
  return SourceRange(Loc, EndLoc);
}

ParsedAttributesView AttrList;

struct PointerTypeInfo {
  /// The type qualifiers: const/volatile/restrict/unaligned/atomic.
  unsigned TypeQuals : 5;

  /// The location of the const-qualifier, if any.
  SourceLocation ConstQualLoc;

  /// The location of the volatile-qualifier, if any.
  SourceLocation VolatileQualLoc;

  /// The location of the restrict-qualifier, if any.
  SourceLocation RestrictQualLoc;

  /// The location of the _Atomic-qualifier, if any.
  SourceLocation AtomicQualLoc;

  /// The location of the __unaligned-qualifier, if any.
  SourceLocation UnalignedQualLoc;

  void destroy() {
  }
};

struct ReferenceTypeInfo {
  /// The type qualifier: restrict. [GNU] C++ extension
  bool HasRestrict : 1;
  /// True if this is an lvalue reference, false if it's an rvalue reference.
  bool LValueRef : 1;
  void destroy() {
  }
};

struct ArrayTypeInfo {
  /// The type qualifiers for the array:
  /// const/volatile/restrict/__unaligned/_Atomic.
  unsigned TypeQuals : 5;

  /// True if this dimension included the 'static' keyword.
  unsigned hasStatic : 1;

  /// True if this dimension was [*].  In this case, NumElts is null.
  unsigned isStar : 1;

  /// This is the size of the array, or null if [] or [*] was specified.
  /// Since the parser is multi-purpose, and we don't want to impose a root
  /// expression class on all clients, NumElts is untyped.
  Expr *NumElts;

  void destroy() {}
};

/// ParamInfo - An array of paraminfo objects is allocated whenever a function
/// declarator is parsed.  There are two interesting styles of parameters
/// here:
/// K&R-style identifier lists and parameter type lists.  K&R-style identifier
/// lists will have information about the identifier, but no type information.
/// Parameter type lists will have type info (if the actions module provides
/// it), but may have null identifier info: e.g. for 'void foo(int X, int)'.
struct ParamInfo {
  IdentifierInfo *Ident;
  SourceLocation IdentLoc;
  Decl *Param;

  /// DefaultArgTokens - When the parameter's default argument
  /// cannot be parsed immediately (because it occurs within the
  /// declaration of a member function), it will be stored here as a
  /// sequence of tokens to be parsed once the class definition is
  /// complete. Non-NULL indicates that there is a default argument.
  std::unique_ptr<CachedTokens> DefaultArgTokens;

  ParamInfo() = default;
  ParamInfo(IdentifierInfo *ident, SourceLocation iloc,
            Decl *param,
            std::unique_ptr<CachedTokens> DefArgTokens = nullptr)
    : Ident(ident), IdentLoc(iloc), Param(param),
      DefaultArgTokens(std::move(DefArgTokens)) {}
};

struct TypeAndRange {
  ParsedType Ty;
  SourceRange Range;
};

struct FunctionTypeInfo {
  /// hasPrototype - This is true if the function had at least one typed
  /// parameter.  If the function is () or (a,b,c), then it has no prototype,
  /// and is treated as a K&R-style function.
  unsigned hasPrototype : 1;

  /// isVariadic - If this function has a prototype, and if that
  /// proto ends with ',...)', this is true. When true, EllipsisLoc
  /// contains the location of the ellipsis.
  unsigned isVariadic : 1;

  /// Can this declaration be a constructor-style initializer?
  unsigned isAmbiguous : 1;

  /// Whether the ref-qualifier (if any) is an lvalue reference.
  /// Otherwise, it's an rvalue reference.
  unsigned RefQualifierIsLValueRef : 1;

  /// ExceptionSpecType - An ExceptionSpecificationType value.
  unsigned ExceptionSpecType : 4;

  /// DeleteParams - If this is true, we need to delete[] Params.
  unsigned DeleteParams : 1;

  /// HasTrailingReturnType - If this is true, a trailing return type was
  /// specified.
  unsigned HasTrailingReturnType : 1;

  /// The location of the left parenthesis in the source.
  SourceLocation LParenLoc;

  /// When isVariadic is true, the location of the ellipsis in the source.
  SourceLocation EllipsisLoc;

  /// The location of the right parenthesis in the source.
  SourceLocation RParenLoc;

  /// NumParams - This is the number of formal parameters specified by the
  /// declarator.
  unsigned NumParams;

  /// NumExceptionsOrDecls - This is the number of types in the
  /// dynamic-exception-decl, if the function has one. In C, this is the
  /// number of declarations in the function prototype.
  unsigned NumExceptionsOrDecls;

  /// The location of the ref-qualifier, if any.
  ///
  /// If this is an invalid location, there is no ref-qualifier.
  SourceLocation RefQualifierLoc;

  /// The location of the 'mutable' qualifer in a lambda-declarator, if
  /// any.
  SourceLocation MutableLoc;

  /// The beginning location of the exception specification, if any.
  SourceLocation ExceptionSpecLocBeg;

  /// The end location of the exception specification, if any.
  SourceLocation ExceptionSpecLocEnd;

  /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
  /// describe the parameters specified by this function declarator.  null if
  /// there are no parameters specified.
  ParamInfo *Params;

  /// DeclSpec for the function with the qualifier related info.
  DeclSpec *MethodQualifiers;

  /// AtttibuteFactory for the MethodQualifiers.
  AttributeFactory *QualAttrFactory;

  union {
    /// Pointer to a new[]'d array of TypeAndRange objects that
    /// contain the types in the function's dynamic exception specification
    /// and their locations, if there is one.
    TypeAndRange *Exceptions;

    /// Pointer to the expression in the noexcept-specifier of this
    /// function, if it has one.
    Expr *NoexceptExpr;

    /// Pointer to the cached tokens for an exception-specification
    /// that has not yet been parsed.
    CachedTokens *ExceptionSpecTokens;

    /// Pointer to a new[]'d array of declarations that need to be available
    /// for lookup inside the function body, if one exists. Does not exist in
    /// C++.
    NamedDecl **DeclsInPrototype;
  };

  /// If HasTrailingReturnType is true, this is the trailing return
  /// type specified.
  UnionParsedType TrailingReturnType;

  /// If HasTrailingReturnType is true, this is the location of the trailing
  /// return type.
  SourceLocation TrailingReturnTypeLoc;

  /// Reset the parameter list to having zero parameters.
  ///
  /// This is used in various places for error recovery.
  void freeParams() {
    for (unsigned I = 0; I < NumParams; ++I)
      Params[I].DefaultArgTokens.reset();
    if (DeleteParams) {
      delete[] Params;
      DeleteParams = false;
    }
    NumParams = 0;
  }

  void destroy() {
    freeParams();
    delete QualAttrFactory;
    delete MethodQualifiers;
    switch (getExceptionSpecType()) {
    default:
      break;
    case EST_Dynamic:
      delete[] Exceptions;
      break;
    case EST_Unparsed:
      delete ExceptionSpecTokens;
      break;
    case EST_None:
      if (NumExceptionsOrDecls != 0)
        delete[] DeclsInPrototype;
      break;
    }
  }

  DeclSpec &getOrCreateMethodQualifiers() {
    if (!MethodQualifiers) {
      QualAttrFactory = new AttributeFactory();
      MethodQualifiers = new DeclSpec(*QualAttrFactory);
    }
    return *MethodQualifiers;
  }

  /// isKNRPrototype - Return true if this is a K&R style identifier list,
  /// like "void foo(a,b,c)".  In a function definition, this will be followed
  /// by the parameter type definitions.
  bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; }

  SourceLocation getLParenLoc() const { return LParenLoc; }

  SourceLocation getEllipsisLoc() const { return EllipsisLoc; }

  SourceLocation getRParenLoc() const { return RParenLoc; }

  SourceLocation getExceptionSpecLocBeg() const {
    return ExceptionSpecLocBeg;
  }

  SourceLocation getExceptionSpecLocEnd() const {
    return ExceptionSpecLocEnd;
  }

  SourceRange getExceptionSpecRange() const {
    return SourceRange(getExceptionSpecLocBeg(), getExceptionSpecLocEnd());
  }

  /// Retrieve the location of the ref-qualifier, if any.
  SourceLocation getRefQualifierLoc() const { return RefQualifierLoc; }

  /// Retrieve the location of the 'const' qualifier.
  SourceLocation getConstQualifierLoc() const {
    assert(MethodQualifiers)((void)0);
    return MethodQualifiers->getConstSpecLoc();
  }

  /// Retrieve the location of the 'volatile' qualifier.
  SourceLocation getVolatileQualifierLoc() const {
    assert(MethodQualifiers)((void)0);
    return MethodQualifiers->getVolatileSpecLoc();
  }

  /// Retrieve the location of the 'restrict' qualifier.
  SourceLocation getRestrictQualifierLoc() const {
    assert(MethodQualifiers)((void)0);
    return MethodQualifiers->getRestrictSpecLoc();
  }

  /// Retrieve the location of the 'mutable' qualifier, if any.
  SourceLocation getMutableLoc() const { return MutableLoc; }

  /// Determine whether this function declaration contains a
  /// ref-qualifier.
  bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }

  /// Determine whether this lambda-declarator contains a 'mutable'
  /// qualifier.
  bool hasMutableQualifier() const { return getMutableLoc().isValid(); }

  /// Determine whether this method has qualifiers.
  bool hasMethodTypeQualifiers() const {
    return MethodQualifiers && (MethodQualifiers->getTypeQualifiers() ||
                                MethodQualifiers->getAttributes().size());
  }

  /// Get the type of exception specification this function has.
  ExceptionSpecificationType getExceptionSpecType() const {
    return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
  }

  /// Get the number of dynamic exception specifications.
  unsigned getNumExceptions() const {
    assert(ExceptionSpecType != EST_None)((void)0);
    return NumExceptionsOrDecls;
  }

  /// Get the non-parameter decls defined within this function
  /// prototype. Typically these are tag declarations.
  ArrayRef<NamedDecl *> getDeclsInPrototype() const {
    assert(ExceptionSpecType == EST_None)((void)0);
    return llvm::makeArrayRef(DeclsInPrototype, NumExceptionsOrDecls);
  }

  /// Determine whether this function declarator had a
  /// trailing-return-type.
  bool hasTrailingReturnType() const { return HasTrailingReturnType; }

  /// Get the trailing-return-type for this function declarator.
  ParsedType getTrailingReturnType() const {
    assert(HasTrailingReturnType)((void)0);
    return TrailingReturnType;
  }

  /// Get the trailing-return-type location for this function declarator.
  SourceLocation getTrailingReturnTypeLoc() const {
    assert(HasTrailingReturnType)((void)0);
    return TrailingReturnTypeLoc;
  }
};

struct BlockPointerTypeInfo {
  /// For now, sema will catch these as invalid.
  /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
  unsigned TypeQuals : 5;

  void destroy() {
  }
};

struct MemberPointerTypeInfo {
  /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
  unsigned TypeQuals : 5;
  /// Location of the '*' token.
  SourceLocation StarLoc;
  // CXXScopeSpec has a constructor, so it can't be a direct member.
  // So we need some pointer-aligned storage and a bit of trickery.
  alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)];
  CXXScopeSpec &Scope() {
    return *reinterpret_cast<CXXScopeSpec *>(ScopeMem);
  }
  const CXXScopeSpec &Scope() const {
    return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem);
  }
  void destroy() {
    Scope().~CXXScopeSpec();
  }
};

struct PipeTypeInfo {
  /// The access writes.
  unsigned AccessWrites : 3;

  void destroy() {}
};

union {
  PointerTypeInfo       Ptr;
  ReferenceTypeInfo     Ref;
  ArrayTypeInfo         Arr;
  FunctionTypeInfo      Fun;
  BlockPointerTypeInfo  Cls;
  MemberPointerTypeInfo Mem;
  PipeTypeInfo          PipeInfo;
};

void destroy() {
  switch (Kind) {
  case DeclaratorChunk::Function:      return Fun.destroy();
  case DeclaratorChunk::Pointer:       return Ptr.destroy();
  case DeclaratorChunk::BlockPointer:  return Cls.destroy();
  case DeclaratorChunk::Reference:     return Ref.destroy();
  case DeclaratorChunk::Array:         return Arr.destroy();
  case DeclaratorChunk::MemberPointer: return Mem.destroy();
  case DeclaratorChunk::Paren:         return;
  case DeclaratorChunk::Pipe:          return PipeInfo.destroy();
  }
}

/// If there are attributes applied to this declaratorchunk, return
/// them.
const ParsedAttributesView &getAttrs() const { return AttrList; }
ParsedAttributesView &getAttrs() { return AttrList; }

/// Return a DeclaratorChunk for a pointer.
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
                                  SourceLocation ConstQualLoc,
                                  SourceLocation VolatileQualLoc,
                                  SourceLocation RestrictQualLoc,
                                  SourceLocation AtomicQualLoc,
                                  SourceLocation UnalignedQualLoc) {
  DeclaratorChunk I;
  I.Kind                = Pointer;
  I.Loc                 = Loc;
  new (&I.Ptr) PointerTypeInfo;
  I.Ptr.TypeQuals       = TypeQuals;
  I.Ptr.ConstQualLoc    = ConstQualLoc;
  I.Ptr.VolatileQualLoc = VolatileQualLoc;
  I.Ptr.RestrictQualLoc = RestrictQualLoc;
  I.Ptr.AtomicQualLoc   = AtomicQualLoc;
  I.Ptr.UnalignedQualLoc = UnalignedQualLoc;
  return I;
}

/// Return a DeclaratorChunk for a reference.
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
                                    bool lvalue) {
  DeclaratorChunk I;
  I.Kind            = Reference;
  I.Loc             = Loc;
  I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0;
  I.Ref.LValueRef   = lvalue;
  return I;
}

/// Return a DeclaratorChunk for an array.
static DeclaratorChunk getArray(unsigned TypeQuals,
                                bool isStatic, bool isStar, Expr *NumElts,
                                SourceLocation LBLoc, SourceLocation RBLoc) {
  DeclaratorChunk I;
  I.Kind          = Array;
  I.Loc           = LBLoc;
  I.EndLoc        = RBLoc;
  I.Arr.TypeQuals = TypeQuals;
  I.Arr.hasStatic = isStatic;
  I.Arr.isStar    = isStar;
  I.Arr.NumElts   = NumElts;
  return I;
}

/// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
/// "TheDeclarator" is the declarator that this will be added to.
static DeclaratorChunk getFunction(bool HasProto,
                                   bool IsAmbiguous,
                                   SourceLocation LParenLoc,
                                   ParamInfo *Params, unsigned NumParams,
                                   SourceLocation EllipsisLoc,
                                   SourceLocation RParenLoc,
                                   bool RefQualifierIsLvalueRef,
                                   SourceLocation RefQualifierLoc,
                                   SourceLocation MutableLoc,
                                   ExceptionSpecificationType ESpecType,
                                   SourceRange ESpecRange,
                                   ParsedType *Exceptions,
                                   SourceRange *ExceptionRanges,
                                   unsigned NumExceptions,
                                   Expr *NoexceptExpr,
                                   CachedTokens *ExceptionSpecTokens,
                                   ArrayRef<NamedDecl *> DeclsInPrototype,
                                   SourceLocation LocalRangeBegin,
                                   SourceLocation LocalRangeEnd,
                                   Declarator &TheDeclarator,
                                   TypeResult TrailingReturnType =
                                                  TypeResult(),
                                   SourceLocation TrailingReturnTypeLoc =
                                                  SourceLocation(),
                                   DeclSpec *MethodQualifiers = nullptr);

/// Return a DeclaratorChunk for a block.
static DeclaratorChunk getBlockPointer(unsigned TypeQuals,
                                       SourceLocation Loc) {
  DeclaratorChunk I;
  I.Kind          = BlockPointer;
  I.Loc           = Loc;
  I.Cls.TypeQuals = TypeQuals;
  return I;
}

/// Return a DeclaratorChunk for a block.
static DeclaratorChunk getPipe(unsigned TypeQuals,
                               SourceLocation Loc) {
  DeclaratorChunk I;
  I.Kind          = Pipe;
  I.Loc           = Loc;
  I.Cls.TypeQuals = TypeQuals;
  return I;
}

static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS,
                                        unsigned TypeQuals,
                                        SourceLocation StarLoc,
                                        SourceLocation EndLoc) {
  DeclaratorChunk I;
  I.Kind          = MemberPointer;
  I.Loc           = SS.getBeginLoc();
  I.EndLoc = EndLoc;
  new (&I.Mem) MemberPointerTypeInfo;
  I.Mem.StarLoc = StarLoc;
  I.Mem.TypeQuals = TypeQuals;
  new (I.Mem.ScopeMem) CXXScopeSpec(SS);
  return I;
}

/// Return a DeclaratorChunk for a paren.
static DeclaratorChunk getParen(SourceLocation LParenLoc,
                                SourceLocation RParenLoc) {
  DeclaratorChunk I;
  I.Kind          = Paren;
  I.Loc           = LParenLoc;
  I.EndLoc        = RParenLoc;
  return I;
}

bool isParen() const {
  return Kind == Paren;
}
1698};

1700/// A parsed C++17 decomposition declarator of the form
1701///   '[' identifier-list ']'
1702class DecompositionDeclarator {
1703public:
struct Binding {
  IdentifierInfo *Name;
  SourceLocation NameLoc;
};

1709private:
/// The locations of the '[' and ']' tokens.
SourceLocation LSquareLoc, RSquareLoc;

/// The bindings.
Binding *Bindings;
unsigned NumBindings : 31;
unsigned DeleteBindings : 1;

friend class Declarator;

1720public:
DecompositionDeclarator()
    : Bindings(nullptr), NumBindings(0), DeleteBindings(false) {}
DecompositionDeclarator(const DecompositionDeclarator &G) = delete;
DecompositionDeclarator &operator=(const DecompositionDeclarator &G) = delete;
~DecompositionDeclarator() {
  if (DeleteBindings)
    delete[] Bindings;
}

void clear() {
  LSquareLoc = RSquareLoc = SourceLocation();
  if (DeleteBindings)
    delete[] Bindings;
  Bindings = nullptr;
  NumBindings = 0;
  DeleteBindings = false;
}

ArrayRef<Binding> bindings() const {
  return llvm::makeArrayRef(Bindings, NumBindings);
}

bool isSet() const { return LSquareLoc.isValid(); }

SourceLocation getLSquareLoc() const { return LSquareLoc; }
SourceLocation getRSquareLoc() const { return RSquareLoc; }
SourceRange getSourceRange() const {
  return SourceRange(LSquareLoc, RSquareLoc);
}
1750};

1752/// Described the kind of function definition (if any) provided for
1753/// a function.
1754enum class FunctionDefinitionKind {
Declaration,
Definition,
Defaulted,
Deleted
1759};

1761enum class DeclaratorContext {
File,                // File scope declaration.
Prototype,           // Within a function prototype.
ObjCResult,          // An ObjC method result type.
ObjCParameter,       // An ObjC method parameter type.
KNRTypeList,         // K&R type definition list for formals.
TypeName,            // Abstract declarator for types.
FunctionalCast,      // Type in a C++ functional cast expression.
Member,              // Struct/Union field.
Block,               // Declaration within a block in a function.
ForInit,             // Declaration within first part of a for loop.
SelectionInit,       // Declaration within optional init stmt of if/switch.
Condition,           // Condition declaration in a C++ if/switch/while/for.
TemplateParam,       // Within a template parameter list.
CXXNew,              // C++ new-expression.
CXXCatch,            // C++ catch exception-declaration
ObjCCatch,           // Objective-C catch exception-declaration
BlockLiteral,        // Block literal declarator.
LambdaExpr,          // Lambda-expression declarator.
LambdaExprParameter, // Lambda-expression parameter declarator.
ConversionId,        // C++ conversion-type-id.
TrailingReturn,      // C++11 trailing-type-specifier.
TrailingReturnVar,   // C++11 trailing-type-specifier for variable.
TemplateArg,         // Any template argument (in template argument list).
TemplateTypeArg,     // Template type argument (in default argument).
AliasDecl,           // C++11 alias-declaration.
AliasTemplate,       // C++11 alias-declaration template.
RequiresExpr         // C++2a requires-expression.
1789};

1791/// Information about one declarator, including the parsed type
1792/// information and the identifier.
1793///
1794/// When the declarator is fully formed, this is turned into the appropriate
1795/// Decl object.
1796///
1797/// Declarators come in two types: normal declarators and abstract declarators.
1798/// Abstract declarators are used when parsing types, and don't have an
1799/// identifier.  Normal declarators do have ID's.
1800///
1801/// Instances of this class should be a transient object that lives on the
1802/// stack, not objects that are allocated in large quantities on the heap.
1803class Declarator {

1805private:
const DeclSpec &DS;
CXXScopeSpec SS;
UnqualifiedId Name;
SourceRange Range;

/// Where we are parsing this declarator.
DeclaratorContext Context;

/// The C++17 structured binding, if any. This is an alternative to a Name.
DecompositionDeclarator BindingGroup;

/// DeclTypeInfo - This holds each type that the declarator includes as it is
/// parsed.  This is pushed from the identifier out, which means that element
/// #0 will be the most closely bound to the identifier, and
/// DeclTypeInfo.back() will be the least closely bound.
SmallVector<DeclaratorChunk, 8> DeclTypeInfo;

/// InvalidType - Set by Sema::GetTypeForDeclarator().
unsigned InvalidType : 1;

/// GroupingParens - Set by Parser::ParseParenDeclarator().
unsigned GroupingParens : 1;

/// FunctionDefinition - Is this Declarator for a function or member
/// definition and, if so, what kind?
///
/// Actually a FunctionDefinitionKind.
unsigned FunctionDefinition : 2;

/// Is this Declarator a redeclaration?
unsigned Redeclaration : 1;

/// true if the declaration is preceded by \c __extension__.
unsigned Extension : 1;

/// Indicates whether this is an Objective-C instance variable.
unsigned ObjCIvar : 1;

/// Indicates whether this is an Objective-C 'weak' property.
unsigned ObjCWeakProperty : 1;

/// Indicates whether the InlineParams / InlineBindings storage has been used.
unsigned InlineStorageUsed : 1;

/// Indicates whether this declarator has an initializer.
unsigned HasInitializer : 1;

/// Attrs - Attributes.
ParsedAttributes Attrs;

/// The asm label, if specified.
Expr *AsmLabel;

/// \brief The constraint-expression specified by the trailing
/// requires-clause, or null if no such clause was specified.
Expr *TrailingRequiresClause;

/// If this declarator declares a template, its template parameter lists.
ArrayRef<TemplateParameterList *> TemplateParameterLists;

/// If the declarator declares an abbreviated function template, the innermost
/// template parameter list containing the invented and explicit template
/// parameters (if any).
TemplateParameterList *InventedTemplateParameterList;

1871#ifndef _MSC_VER
union {
1873#endif
  /// InlineParams - This is a local array used for the first function decl
  /// chunk to avoid going to the heap for the common case when we have one
  /// function chunk in the declarator.
  DeclaratorChunk::ParamInfo InlineParams[16];
  DecompositionDeclarator::Binding InlineBindings[16];
1879#ifndef _MSC_VER
};
1881#endif

/// If this is the second or subsequent declarator in this declaration,
/// the location of the comma before this declarator.
SourceLocation CommaLoc;

/// If provided, the source location of the ellipsis used to describe
/// this declarator as a parameter pack.
SourceLocation EllipsisLoc;

friend struct DeclaratorChunk;

1893public:
Declarator(const DeclSpec &ds, DeclaratorContext C)
    : DS(ds), Range(ds.getSourceRange()), Context(C),
      InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
      GroupingParens(false), FunctionDefinition(static_cast<unsigned>(
                                 FunctionDefinitionKind::Declaration)),
      Redeclaration(false), Extension(false), ObjCIvar(false),
      ObjCWeakProperty(false), InlineStorageUsed(false),
      HasInitializer(false), Attrs(ds.getAttributePool().getFactory()),
      AsmLabel(nullptr), TrailingRequiresClause(nullptr),
      InventedTemplateParameterList(nullptr) {}

~Declarator() {
  clear();
}
/// getDeclSpec - Return the declaration-specifier that this declarator was
/// declared with.
const DeclSpec &getDeclSpec() const { return DS; }

/// getMutableDeclSpec - Return a non-const version of the DeclSpec.  This
/// should be used with extreme care: declspecs can often be shared between
/// multiple declarators, so mutating the DeclSpec affects all of the
/// Declarators.  This should only be done when the declspec is known to not
/// be shared or when in error recovery etc.
DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); }

AttributePool &getAttributePool() const {
  return Attrs.getPool();
}

/// getCXXScopeSpec - Return the C++ scope specifier (global scope or
/// nested-name-specifier) that is part of the declarator-id.
const CXXScopeSpec &getCXXScopeSpec() const { return SS; }
CXXScopeSpec &getCXXScopeSpec() { return SS; }

/// Retrieve the name specified by this declarator.
UnqualifiedId &getName() { return Name; }

const DecompositionDeclarator &getDecompositionDeclarator() const {
  return BindingGroup;
}

DeclaratorContext getContext() const { return Context; }

bool isPrototypeContext() const {
  return (Context == DeclaratorContext::Prototype ||
          Context == DeclaratorContext::ObjCParameter ||
          Context == DeclaratorContext::ObjCResult ||
          Context == DeclaratorContext::LambdaExprParameter);
}

/// Get the source range that spans this declarator.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }

void SetSourceRange(SourceRange R) { Range = R; }
/// SetRangeBegin - Set the start of the source range to Loc, unless it's
/// invalid.
void SetRangeBegin(SourceLocation Loc) {
  if (!Loc.isInvalid())
    Range.setBegin(Loc);
}
/// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
void SetRangeEnd(SourceLocation Loc) {
  if (!Loc.isInvalid())
    Range.setEnd(Loc);
}
/// ExtendWithDeclSpec - Extend the declarator source range to include the
/// given declspec, unless its location is invalid. Adopts the range start if
/// the current range start is invalid.
void ExtendWithDeclSpec(const DeclSpec &DS) {
  SourceRange SR = DS.getSourceRange();
  if (Range.getBegin().isInvalid())
    Range.setBegin(SR.getBegin());
  if (!SR.getEnd().isInvalid())
    Range.setEnd(SR.getEnd());
}

/// Reset the contents of this Declarator.
void clear() {
  SS.clear();
  Name.clear();
  Range = DS.getSourceRange();
  BindingGroup.clear();

  for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i)
    DeclTypeInfo[i].destroy();
  DeclTypeInfo.clear();
  Attrs.clear();
  AsmLabel = nullptr;
  InlineStorageUsed = false;
  HasInitializer = false;
  ObjCIvar = false;
  ObjCWeakProperty = false;
  CommaLoc = SourceLocation();
  EllipsisLoc = SourceLocation();
}

/// mayOmitIdentifier - Return true if the identifier is either optional or
/// not allowed.  This is true for typenames, prototypes, and template
/// parameter lists.
bool mayOmitIdentifier() const {
  switch (Context) {
  case DeclaratorContext::File:
  case DeclaratorContext::KNRTypeList:
  case DeclaratorContext::Member:
  case DeclaratorContext::Block:
  case DeclaratorContext::ForInit:
  case DeclaratorContext::SelectionInit:
  case DeclaratorContext::Condition:
    return false;

  case DeclaratorContext::TypeName:
  case DeclaratorContext::FunctionalCast:
  case DeclaratorContext::AliasDecl:
  case DeclaratorContext::AliasTemplate:
  case DeclaratorContext::Prototype:
  case DeclaratorContext::LambdaExprParameter:
  case DeclaratorContext::ObjCParameter:
  case DeclaratorContext::ObjCResult:
  case DeclaratorContext::TemplateParam:
  case DeclaratorContext::CXXNew:
  case DeclaratorContext::CXXCatch:
  case DeclaratorContext::ObjCCatch:
  case DeclaratorContext::BlockLiteral:
  case DeclaratorContext::LambdaExpr:
  case DeclaratorContext::ConversionId:
  case DeclaratorContext::TemplateArg:
  case DeclaratorContext::TemplateTypeArg:
  case DeclaratorContext::TrailingReturn:
  case DeclaratorContext::TrailingReturnVar:
  case DeclaratorContext::RequiresExpr:
    return true;
  }
  llvm_unreachable("unknown context kind!")__builtin_unreachable();
}

/// mayHaveIdentifier - Return true if the identifier is either optional or
/// required.  This is true for normal declarators and prototypes, but not
/// typenames.
bool mayHaveIdentifier() const {
  switch (Context) {
  case DeclaratorContext::File:
  case DeclaratorContext::KNRTypeList:
  case DeclaratorContext::Member:
  case DeclaratorContext::Block:
  case DeclaratorContext::ForInit:
  case DeclaratorContext::SelectionInit:
  case DeclaratorContext::Condition:
  case DeclaratorContext::Prototype:
  case DeclaratorContext::LambdaExprParameter:
  case DeclaratorContext::TemplateParam:
  case DeclaratorContext::CXXCatch:
  case DeclaratorContext::ObjCCatch:
  case DeclaratorContext::RequiresExpr:
    return true;

  case DeclaratorContext::TypeName:
  case DeclaratorContext::FunctionalCast:
  case DeclaratorContext::CXXNew:
  case DeclaratorContext::AliasDecl:
  case DeclaratorContext::AliasTemplate:
  case DeclaratorContext::ObjCParameter:
  case DeclaratorContext::ObjCResult:
  case DeclaratorContext::BlockLiteral:
  case DeclaratorContext::LambdaExpr:
  case DeclaratorContext::ConversionId:
  case DeclaratorContext::TemplateArg:
  case DeclaratorContext::TemplateTypeArg:
  case DeclaratorContext::TrailingReturn:
  case DeclaratorContext::TrailingReturnVar:
    return false;
  }
  llvm_unreachable("unknown context kind!")__builtin_unreachable();
}

/// Return true if the context permits a C++17 decomposition declarator.
bool mayHaveDecompositionDeclarator() const {
  switch (Context) {
  case DeclaratorContext::File:
    // FIXME: It's not clear that the proposal meant to allow file-scope
    // structured bindings, but it does.
  case DeclaratorContext::Block:
  case DeclaratorContext::ForInit:
  case DeclaratorContext::SelectionInit:
  case DeclaratorContext::Condition:
    return true;

  case DeclaratorContext::Member:
  case DeclaratorContext::Prototype:
  case DeclaratorContext::TemplateParam:
  case DeclaratorContext::RequiresExpr:
    // Maybe one day...
    return false;

  // These contexts don't allow any kind of non-abstract declarator.
  case DeclaratorContext::KNRTypeList:
  case DeclaratorContext::TypeName:
  case DeclaratorContext::FunctionalCast:
  case DeclaratorContext::AliasDecl:
  case DeclaratorContext::AliasTemplate:
  case DeclaratorContext::LambdaExprParameter:
  case DeclaratorContext::ObjCParameter:
  case DeclaratorContext::ObjCResult:
  case DeclaratorContext::CXXNew:
  case DeclaratorContext::CXXCatch:
  case DeclaratorContext::ObjCCatch:
  case DeclaratorContext::BlockLiteral:
  case DeclaratorContext::LambdaExpr:
  case DeclaratorContext::ConversionId:
  case DeclaratorContext::TemplateArg:
  case DeclaratorContext::TemplateTypeArg:
  case DeclaratorContext::TrailingReturn:
  case DeclaratorContext::TrailingReturnVar:
    return false;
  }
  llvm_unreachable("unknown context kind!")__builtin_unreachable();
}

/// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
/// followed by a C++ direct initializer, e.g. "int x(1);".
bool mayBeFollowedByCXXDirectInit() const {
  if (hasGroupingParens()) return false;

  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
    return false;

  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern &&
      Context != DeclaratorContext::File)
    return false;

  // Special names can't have direct initializers.
  if (Name.getKind() != UnqualifiedIdKind::IK_Identifier)
    return false;

  switch (Context) {
  case DeclaratorContext::File:
  case DeclaratorContext::Block:
  case DeclaratorContext::ForInit:
  case DeclaratorContext::SelectionInit:
  case DeclaratorContext::TrailingReturnVar:
    return true;

  case DeclaratorContext::Condition:
    // This may not be followed by a direct initializer, but it can't be a
    // function declaration either, and we'd prefer to perform a tentative
    // parse in order to produce the right diagnostic.
    return true;

  case DeclaratorContext::KNRTypeList:
  case DeclaratorContext::Member:
  case DeclaratorContext::Prototype:
  case DeclaratorContext::LambdaExprParameter:
  case DeclaratorContext::ObjCParameter:
  case DeclaratorContext::ObjCResult:
  case DeclaratorContext::TemplateParam:
  case DeclaratorContext::CXXCatch:
  case DeclaratorContext::ObjCCatch:
  case DeclaratorContext::TypeName:
  case DeclaratorContext::FunctionalCast: // FIXME
  case DeclaratorContext::CXXNew:
  case DeclaratorContext::AliasDecl:
  case DeclaratorContext::AliasTemplate:
  case DeclaratorContext::BlockLiteral:
  case DeclaratorContext::LambdaExpr:
  case DeclaratorContext::ConversionId:
  case DeclaratorContext::TemplateArg:
  case DeclaratorContext::TemplateTypeArg:
  case DeclaratorContext::TrailingReturn:
  case DeclaratorContext::RequiresExpr:
    return false;
  }
  llvm_unreachable("unknown context kind!")__builtin_unreachable();
}

/// isPastIdentifier - Return true if we have parsed beyond the point where
/// the name would appear. (This may happen even if we haven't actually parsed
/// a name, perhaps because this context doesn't require one.)
bool isPastIdentifier() const { return Name.isValid(); }

/// hasName - Whether this declarator has a name, which might be an
/// identifier (accessible via getIdentifier()) or some kind of
/// special C++ name (constructor, destructor, etc.), or a structured
/// binding (which is not exactly a name, but occupies the same position).
bool hasName() const {
  return Name.getKind() != UnqualifiedIdKind::IK_Identifier ||
         Name.Identifier || isDecompositionDeclarator();
}

/// Return whether this declarator is a decomposition declarator.
bool isDecompositionDeclarator() const {
  return BindingGroup.isSet();
}

IdentifierInfo *getIdentifier() const {
  if (Name.getKind() == UnqualifiedIdKind::IK_Identifier)
    return Name.Identifier;

  return nullptr;
}
SourceLocation getIdentifierLoc() const { return Name.StartLocation; }

/// Set the name of this declarator to be the given identifier.
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) {
  Name.setIdentifier(Id, IdLoc);
}

/// Set the decomposition bindings for this declarator.
void
setDecompositionBindings(SourceLocation LSquareLoc,
                         ArrayRef<DecompositionDeclarator::Binding> Bindings,
                         SourceLocation RSquareLoc);

/// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
/// EndLoc, which should be the last token of the chunk.
/// This function takes attrs by R-Value reference because it takes ownership
/// of those attributes from the parameter.
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs,
                 SourceLocation EndLoc) {
  DeclTypeInfo.push_back(TI);
  DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end());
  getAttributePool().takeAllFrom(attrs.getPool());

  if (!EndLoc.isInvalid())
    SetRangeEnd(EndLoc);
}

/// AddTypeInfo - Add a chunk to this declarator. Also extend the range to
/// EndLoc, which should be the last token of the chunk.
void AddTypeInfo(const DeclaratorChunk &TI, SourceLocation EndLoc) {
  DeclTypeInfo.push_back(TI);

  if (!EndLoc.isInvalid())
    SetRangeEnd(EndLoc);
}

/// Add a new innermost chunk to this declarator.
void AddInnermostTypeInfo(const DeclaratorChunk &TI) {
  DeclTypeInfo.insert(DeclTypeInfo.begin(), TI);
}

/// Return the number of types applied to this declarator.
unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); }

/// Return the specified TypeInfo from this declarator.  TypeInfo #0 is
/// closest to the identifier.
const DeclaratorChunk &getTypeObject(unsigned i) const {
  assert(i < DeclTypeInfo.size() && "Invalid type chunk")((void)0);
  return DeclTypeInfo[i];
}
DeclaratorChunk &getTypeObject(unsigned i) {
  assert(i < DeclTypeInfo.size() && "Invalid type chunk")((void)0);
  return DeclTypeInfo[i];
}

typedef SmallVectorImpl<DeclaratorChunk>::const_iterator type_object_iterator;
typedef llvm::iterator_range<type_object_iterator> type_object_range;

/// Returns the range of type objects, from the identifier outwards.
type_object_range type_objects() const {
  return type_object_range(DeclTypeInfo.begin(), DeclTypeInfo.end());
}

void DropFirstTypeObject() {
  assert(!DeclTypeInfo.empty() && "No type chunks to drop.")((void)0);
  DeclTypeInfo.front().destroy();
  DeclTypeInfo.erase(DeclTypeInfo.begin());
}

/// Return the innermost (closest to the declarator) chunk of this
/// declarator that is not a parens chunk, or null if there are no
/// non-parens chunks.
const DeclaratorChunk *getInnermostNonParenChunk() const {
  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
    if (!DeclTypeInfo[i].isParen())
      return &DeclTypeInfo[i];
  }
  return nullptr;
}

/// Return the outermost (furthest from the declarator) chunk of
/// this declarator that is not a parens chunk, or null if there are
/// no non-parens chunks.
const DeclaratorChunk *getOutermostNonParenChunk() const {
  for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) {
    if (!DeclTypeInfo[i-1].isParen())
      return &DeclTypeInfo[i-1];
  }
  return nullptr;
}

/// isArrayOfUnknownBound - This method returns true if the declarator
/// is a declarator for an array of unknown bound (looking through
/// parentheses).
bool isArrayOfUnknownBound() const {
  const DeclaratorChunk *chunk = getInnermostNonParenChunk();
  return (chunk && chunk->Kind == DeclaratorChunk::Array &&
          !chunk->Arr.NumElts);
}

/// isFunctionDeclarator - This method returns true if the declarator
/// is a function declarator (looking through parentheses).
/// If true is returned, then the reference type parameter idx is
/// assigned with the index of the declaration chunk.
bool isFunctionDeclarator(unsigned& idx) const {
  for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
    switch (DeclTypeInfo[i].Kind) {
    case DeclaratorChunk::Function:
      idx = i;
      return true;
    case DeclaratorChunk::Paren:
      continue;
    case DeclaratorChunk::Pointer:
    case DeclaratorChunk::Reference:
    case DeclaratorChunk::Array:
    case DeclaratorChunk::BlockPointer:
    case DeclaratorChunk::MemberPointer:
    case DeclaratorChunk::Pipe:
      return false;
    }
    llvm_unreachable("Invalid type chunk")__builtin_unreachable();
  }
  return false;
}

/// isFunctionDeclarator - Once this declarator is fully parsed and formed,
/// this method returns true if the identifier is a function declarator
/// (looking through parentheses).
bool isFunctionDeclarator() const {
  unsigned index;
  return isFunctionDeclarator(index);
}

/// getFunctionTypeInfo - Retrieves the function type info object
/// (looking through parentheses).
DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() {
  assert(isFunctionDeclarator() && "Not a function declarator!")((void)0);
  unsigned index = 0;
  isFunctionDeclarator(index);
  return DeclTypeInfo[index].Fun;
}

/// getFunctionTypeInfo - Retrieves the function type info object
/// (looking through parentheses).
const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const {
  return const_cast<Declarator*>(this)->getFunctionTypeInfo();
}

/// Determine whether the declaration that will be produced from
/// this declaration will be a function.
///
/// A declaration can declare a function even if the declarator itself
/// isn't a function declarator, if the type specifier refers to a function
/// type. This routine checks for both cases.
bool isDeclarationOfFunction() const;

/// Return true if this declaration appears in a context where a
/// function declarator would be a function declaration.
bool isFunctionDeclarationContext() const {
  if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
    return false;

  switch (Context) {
  case DeclaratorContext::File:
  case DeclaratorContext::Member:
  case DeclaratorContext::Block:
  case DeclaratorContext::ForInit:
  case DeclaratorContext::SelectionInit:
    return true;

  case DeclaratorContext::Condition:
  case DeclaratorContext::KNRTypeList:
  case DeclaratorContext::TypeName:
  case DeclaratorContext::FunctionalCast:
  case DeclaratorContext::AliasDecl:
  case DeclaratorContext::AliasTemplate:
  case DeclaratorContext::Prototype:
  case DeclaratorContext::LambdaExprParameter:
  case DeclaratorContext::ObjCParameter:
  case DeclaratorContext::ObjCResult:
  case DeclaratorContext::TemplateParam:
  case DeclaratorContext::CXXNew:
  case DeclaratorContext::CXXCatch:
  case DeclaratorContext::ObjCCatch:
  case DeclaratorContext::BlockLiteral:
  case DeclaratorContext::LambdaExpr:
  case DeclaratorContext::ConversionId:
  case DeclaratorContext::TemplateArg:
  case DeclaratorContext::TemplateTypeArg:
  case DeclaratorContext::TrailingReturn:
  case DeclaratorContext::TrailingReturnVar:
  case DeclaratorContext::RequiresExpr:
    return false;
  }
  llvm_unreachable("unknown context kind!")__builtin_unreachable();
}

/// Determine whether this declaration appears in a context where an
/// expression could appear.
bool isExpressionContext() const {
  switch (Context) {
  case DeclaratorContext::File:
  case DeclaratorContext::KNRTypeList:
  case DeclaratorContext::Member:

  // FIXME: sizeof(...) permits an expression.
  case DeclaratorContext::TypeName:

  case DeclaratorContext::FunctionalCast:
  case DeclaratorContext::AliasDecl:
  case DeclaratorContext::AliasTemplate:
  case DeclaratorContext::Prototype:
  case DeclaratorContext::LambdaExprParameter:
  case DeclaratorContext::ObjCParameter:
  case DeclaratorContext::ObjCResult:
  case DeclaratorContext::TemplateParam:
  case DeclaratorContext::CXXNew:
  case DeclaratorContext::CXXCatch:
  case DeclaratorContext::ObjCCatch:
  case DeclaratorContext::BlockLiteral:
  case DeclaratorContext::LambdaExpr:
  case DeclaratorContext::ConversionId:
  case DeclaratorContext::TrailingReturn:
  case DeclaratorContext::TrailingReturnVar:
  case DeclaratorContext::TemplateTypeArg:
  case DeclaratorContext::RequiresExpr:
    return false;

  case DeclaratorContext::Block:
  case DeclaratorContext::ForInit:
  case DeclaratorContext::SelectionInit:
  case DeclaratorContext::Condition:
  case DeclaratorContext::TemplateArg:
    return true;
  }

  llvm_unreachable("unknown context kind!")__builtin_unreachable();
}

/// Return true if a function declarator at this position would be a
/// function declaration.
bool isFunctionDeclaratorAFunctionDeclaration() const {
  if (!isFunctionDeclarationContext())
    return false;

  for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I)
    if (getTypeObject(I).Kind != DeclaratorChunk::Paren)
      return false;

  return true;
}

/// Determine whether a trailing return type was written (at any
/// level) within this declarator.
bool hasTrailingReturnType() const {
  for (const auto &Chunk : type_objects())
    if (Chunk.Kind == DeclaratorChunk::Function &&
        Chunk.Fun.hasTrailingReturnType())
      return true;
  return false;
}
/// Get the trailing return type appearing (at any level) within this
/// declarator.
ParsedType getTrailingReturnType() const {
  for (const auto &Chunk : type_objects())
    if (Chunk.Kind == DeclaratorChunk::Function &&
        Chunk.Fun.hasTrailingReturnType())
      return Chunk.Fun.getTrailingReturnType();
  return ParsedType();
}

/// \brief Sets a trailing requires clause for this declarator.
void setTrailingRequiresClause(Expr *TRC) {
  TrailingRequiresClause = TRC;

  SetRangeEnd(TRC->getEndLoc());
}

/// \brief Sets a trailing requires clause for this declarator.
Expr *getTrailingRequiresClause() {
  return TrailingRequiresClause;
}

/// \brief Determine whether a trailing requires clause was written in this
/// declarator.
bool hasTrailingRequiresClause() const {
  return TrailingRequiresClause != nullptr;
}

/// Sets the template parameter lists that preceded the declarator.
void setTemplateParameterLists(ArrayRef<TemplateParameterList *> TPLs) {
  TemplateParameterLists = TPLs;
}

/// The template parameter lists that preceded the declarator.
ArrayRef<TemplateParameterList *> getTemplateParameterLists() const {
  return TemplateParameterLists;
}

/// Sets the template parameter list generated from the explicit template
/// parameters along with any invented template parameters from
/// placeholder-typed parameters.
void setInventedTemplateParameterList(TemplateParameterList *Invented) {
  InventedTemplateParameterList = Invented;
}

/// The template parameter list generated from the explicit template
/// parameters along with any invented template parameters from
/// placeholder-typed parameters, if there were any such parameters.
TemplateParameterList * getInventedTemplateParameterList() const {
  return InventedTemplateParameterList;
}

/// takeAttributes - Takes attributes from the given parsed-attributes
/// set and add them to this declarator.
///
/// These examples both add 3 attributes to "var":
///  short int var __attribute__((aligned(16),common,deprecated));
///  short int x, __attribute__((aligned(16)) var
///                                 __attribute__((common,deprecated));
///
/// Also extends the range of the declarator.
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc) {
  Attrs.takeAllFrom(attrs);

  if (!lastLoc.isInvalid())
    SetRangeEnd(lastLoc);
}

const ParsedAttributes &getAttributes() const { return Attrs; }
ParsedAttributes &getAttributes() { return Attrs; }

/// hasAttributes - do we contain any attributes?
bool hasAttributes() const {
  if (!getAttributes().empty() || getDeclSpec().hasAttributes())
    return true;
  for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i)
    if (!getTypeObject(i).getAttrs().empty())
      return true;
  return false;
}

/// Return a source range list of C++11 attributes associated
/// with the declarator.
void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) {
  for (const ParsedAttr &AL : Attrs)
    if (AL.isCXX11Attribute())
      Ranges.push_back(AL.getRange());
}

void setAsmLabel(Expr *E) { AsmLabel = E; }
Expr *getAsmLabel() const { return AsmLabel; }

void setExtension(bool Val = true) { Extension = Val; }
bool getExtension() const { return Extension; }

void setObjCIvar(bool Val = true) { ObjCIvar = Val; }
bool isObjCIvar() const { return ObjCIvar; }

void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; }
bool isObjCWeakProperty() const { return ObjCWeakProperty; }

void setInvalidType(bool Val = true) { InvalidType = Val; }
bool isInvalidType() const {
  return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error;
}

void setGroupingParens(bool flag) { GroupingParens = flag; }
bool hasGroupingParens() const { return GroupingParens; }

bool isFirstDeclarator() const { return !CommaLoc.isValid(); }
SourceLocation getCommaLoc() const { return CommaLoc; }
void setCommaLoc(SourceLocation CL) { CommaLoc = CL; }

bool hasEllipsis() const { return EllipsisLoc.isValid(); }
SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; }

void setFunctionDefinitionKind(FunctionDefinitionKind Val) {
  FunctionDefinition = static_cast<unsigned>(Val);
}

bool isFunctionDefinition() const {
  return getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration;
}

FunctionDefinitionKind getFunctionDefinitionKind() const {
  return (FunctionDefinitionKind)FunctionDefinition;
}

void setHasInitializer(bool Val = true) { HasInitializer = Val; }
bool hasInitializer() const { return HasInitializer; }

/// Returns true if this declares a real member and not a friend.
bool isFirstDeclarationOfMember() {
  return getContext() == DeclaratorContext::Member &&
         !getDeclSpec().isFriendSpecified();
}

/// Returns true if this declares a static member.  This cannot be called on a
/// declarator outside of a MemberContext because we won't know until
/// redeclaration time if the decl is static.
bool isStaticMember();

/// Returns true if this declares a constructor or a destructor.
bool isCtorOrDtor();

void setRedeclaration(bool Val) { Redeclaration = Val; }
bool isRedeclaration() const { return Redeclaration; }
2603};

2605/// This little struct is used to capture information about
2606/// structure field declarators, which is basically just a bitfield size.
2607struct FieldDeclarator {
Declarator D;
Expr *BitfieldSize;
explicit FieldDeclarator(const DeclSpec &DS)
    : D(DS, DeclaratorContext::Member), BitfieldSize(nullptr) {}
2612};

2614/// Represents a C++11 virt-specifier-seq.
2615class VirtSpecifiers {
2616public:
enum Specifier {
  VS_None = 0,
  VS_Override = 1,
  VS_Final = 2,
  VS_Sealed = 4,
  // Represents the __final keyword, which is legal for gcc in pre-C++11 mode.
  VS_GNU_Final = 8,
  VS_Abstract = 16
};

VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { }

bool SetSpecifier(Specifier VS, SourceLocation Loc,
                  const char *&PrevSpec);

bool isUnset() const { return Specifiers == 0; }

bool isOverrideSpecified() const { return Specifiers & VS_Override; }
SourceLocation getOverrideLoc() const { return VS_overrideLoc; }

bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed | VS_GNU_Final); }
bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; }
SourceLocation getFinalLoc() const { return VS_finalLoc; }
SourceLocation getAbstractLoc() const { return VS_abstractLoc; }

void clear() { Specifiers = 0; }

static const char *getSpecifierName(Specifier VS);

SourceLocation getFirstLocation() const { return FirstLocation; }
SourceLocation getLastLocation() const { return LastLocation; }
Specifier getLastSpecifier() const { return LastSpecifier; }

2650private:
unsigned Specifiers;
Specifier LastSpecifier;

SourceLocation VS_overrideLoc, VS_finalLoc, VS_abstractLoc;
SourceLocation FirstLocation;
SourceLocation LastLocation;
2657};

2659enum class LambdaCaptureInitKind {
NoInit,     //!< [a]
CopyInit,   //!< [a = b], [a = {b}]
DirectInit, //!< [a(b)]
ListInit    //!< [a{b}]
2664};

2666/// Represents a complete lambda introducer.
2667struct LambdaIntroducer {
/// An individual capture in a lambda introducer.
struct LambdaCapture {
  LambdaCaptureKind Kind;
  SourceLocation Loc;
  IdentifierInfo *Id;
  SourceLocation EllipsisLoc;
  LambdaCaptureInitKind InitKind;
  ExprResult Init;
  ParsedType InitCaptureType;
  SourceRange ExplicitRange;

  LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc,
                IdentifierInfo *Id, SourceLocation EllipsisLoc,
                LambdaCaptureInitKind InitKind, ExprResult Init,
                ParsedType InitCaptureType,
                SourceRange ExplicitRange)
      : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc),
        InitKind(InitKind), Init(Init), InitCaptureType(InitCaptureType),
        ExplicitRange(ExplicitRange) {}
};

SourceRange Range;
SourceLocation DefaultLoc;
LambdaCaptureDefault Default;
SmallVector<LambdaCapture, 4> Captures;

LambdaIntroducer()
  : Default(LCD_None) {}

/// Append a capture in a lambda introducer.
void addCapture(LambdaCaptureKind Kind,
                SourceLocation Loc,
                IdentifierInfo* Id,
                SourceLocation EllipsisLoc,
                LambdaCaptureInitKind InitKind,
                ExprResult Init,
                ParsedType InitCaptureType,
                SourceRange ExplicitRange) {
  Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
                                   InitCaptureType, ExplicitRange));
}
2709};

2711struct InventedTemplateParameterInfo {
/// The number of parameters in the template parameter list that were
/// explicitly specified by the user, as opposed to being invented by use
/// of an auto parameter.
unsigned NumExplicitTemplateParams = 0;

/// If this is a generic lambda or abbreviated function template, use this
/// as the depth of each 'auto' parameter, during initial AST construction.
unsigned AutoTemplateParameterDepth = 0;

/// Store the list of the template parameters for a generic lambda or an
/// abbreviated function template.
/// If this is a generic lambda or abbreviated function template, this holds
/// the explicit template parameters followed by the auto parameters
/// converted into TemplateTypeParmDecls.
/// It can be used to construct the generic lambda or abbreviated template's
/// template parameter list during initial AST construction.
SmallVector<NamedDecl*, 4> TemplateParams;
2729};

2731} // end namespace clang

2733#endif // LLVM_CLANG_SEMA_DECLSPEC_H