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

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplate.cpp
Warning:	line 4690, column 7 Forming reference to null pointer

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 SemaTemplate.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/SemaTemplate.cpp

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

→

1//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
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//  This file implements semantic analysis for C++ templates.
9//===----------------------------------------------------------------------===//

11#include "TreeTransform.h"
12#include "clang/AST/ASTConsumer.h"
13#include "clang/AST/ASTContext.h"
14#include "clang/AST/DeclFriend.h"
15#include "clang/AST/DeclTemplate.h"
16#include "clang/AST/Expr.h"
17#include "clang/AST/ExprCXX.h"
18#include "clang/AST/RecursiveASTVisitor.h"
19#include "clang/AST/TypeVisitor.h"
20#include "clang/Basic/Builtins.h"
21#include "clang/Basic/LangOptions.h"
22#include "clang/Basic/PartialDiagnostic.h"
23#include "clang/Basic/Stack.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Sema/DeclSpec.h"
26#include "clang/Sema/Initialization.h"
27#include "clang/Sema/Lookup.h"
28#include "clang/Sema/Overload.h"
29#include "clang/Sema/ParsedTemplate.h"
30#include "clang/Sema/Scope.h"
31#include "clang/Sema/SemaInternal.h"
32#include "clang/Sema/Template.h"
33#include "clang/Sema/TemplateDeduction.h"
34#include "llvm/ADT/SmallBitVector.h"
35#include "llvm/ADT/SmallString.h"
36#include "llvm/ADT/StringExtras.h"

38#include <iterator>
39using namespace clang;
40using namespace sema;

42// Exported for use by Parser.
43SourceRange
44clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
                            unsigned N) {
if (!N) return SourceRange();
return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
48}

50unsigned Sema::getTemplateDepth(Scope *S) const {
unsigned Depth = 0;

// Each template parameter scope represents one level of template parameter
// depth.
for (Scope *TempParamScope = S->getTemplateParamParent(); TempParamScope;
     TempParamScope = TempParamScope->getParent()->getTemplateParamParent()) {
  ++Depth;
}

// Note that there are template parameters with the given depth.
auto ParamsAtDepth = [&](unsigned D) { Depth = std::max(Depth, D + 1); };

// Look for parameters of an enclosing generic lambda. We don't create a
// template parameter scope for these.
for (FunctionScopeInfo *FSI : getFunctionScopes()) {
  if (auto *LSI = dyn_cast<LambdaScopeInfo>(FSI)) {
    if (!LSI->TemplateParams.empty()) {
      ParamsAtDepth(LSI->AutoTemplateParameterDepth);
      break;
    }
    if (LSI->GLTemplateParameterList) {
      ParamsAtDepth(LSI->GLTemplateParameterList->getDepth());
      break;
    }
  }
}

// Look for parameters of an enclosing terse function template. We don't
// create a template parameter scope for these either.
for (const InventedTemplateParameterInfo &Info :
     getInventedParameterInfos()) {
  if (!Info.TemplateParams.empty()) {
    ParamsAtDepth(Info.AutoTemplateParameterDepth);
    break;
  }
}

return Depth;
89}

91/// \brief Determine whether the declaration found is acceptable as the name
92/// of a template and, if so, return that template declaration. Otherwise,
93/// returns null.
94///
95/// Note that this may return an UnresolvedUsingValueDecl if AllowDependent
96/// is true. In all other cases it will return a TemplateDecl (or null).
97NamedDecl *Sema::getAsTemplateNameDecl(NamedDecl *D,
                                     bool AllowFunctionTemplates,
                                     bool AllowDependent) {
D = D->getUnderlyingDecl();

if (isa<TemplateDecl>(D)) {
  if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
    return nullptr;

  return D;
}

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
  // C++ [temp.local]p1:
  //   Like normal (non-template) classes, class templates have an
  //   injected-class-name (Clause 9). The injected-class-name
  //   can be used with or without a template-argument-list. When
  //   it is used without a template-argument-list, it is
  //   equivalent to the injected-class-name followed by the
  //   template-parameters of the class template enclosed in
  //   <>. When it is used with a template-argument-list, it
  //   refers to the specified class template specialization,
  //   which could be the current specialization or another
  //   specialization.
  if (Record->isInjectedClassName()) {
    Record = cast<CXXRecordDecl>(Record->getDeclContext());
    if (Record->getDescribedClassTemplate())
      return Record->getDescribedClassTemplate();

    if (ClassTemplateSpecializationDecl *Spec
          = dyn_cast<ClassTemplateSpecializationDecl>(Record))
      return Spec->getSpecializedTemplate();
  }

  return nullptr;
}

// 'using Dependent::foo;' can resolve to a template name.
// 'using typename Dependent::foo;' cannot (not even if 'foo' is an
// injected-class-name).
if (AllowDependent && isa<UnresolvedUsingValueDecl>(D))
  return D;

return nullptr;
141}

143void Sema::FilterAcceptableTemplateNames(LookupResult &R,
                                       bool AllowFunctionTemplates,
                                       bool AllowDependent) {
LookupResult::Filter filter = R.makeFilter();
while (filter.hasNext()) {
  NamedDecl *Orig = filter.next();
  if (!getAsTemplateNameDecl(Orig, AllowFunctionTemplates, AllowDependent))
    filter.erase();
}
filter.done();
153}

155bool Sema::hasAnyAcceptableTemplateNames(LookupResult &R,
                                       bool AllowFunctionTemplates,
                                       bool AllowDependent,
                                       bool AllowNonTemplateFunctions) {
for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
  if (getAsTemplateNameDecl(*I, AllowFunctionTemplates, AllowDependent))
    return true;
  if (AllowNonTemplateFunctions &&
      isa<FunctionDecl>((*I)->getUnderlyingDecl()))
    return true;
}

return false;
168}

170TemplateNameKind Sema::isTemplateName(Scope *S,
                                    CXXScopeSpec &SS,
                                    bool hasTemplateKeyword,
                                    const UnqualifiedId &Name,
                                    ParsedType ObjectTypePtr,
                                    bool EnteringContext,
                                    TemplateTy &TemplateResult,
                                    bool &MemberOfUnknownSpecialization,
                                    bool Disambiguation) {
assert(getLangOpts().CPlusPlus && "No template names in C!")((void)0);

DeclarationName TName;
MemberOfUnknownSpecialization = false;

switch (Name.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
  TName = DeclarationName(Name.Identifier);
  break;

case UnqualifiedIdKind::IK_OperatorFunctionId:
  TName = Context.DeclarationNames.getCXXOperatorName(
                                            Name.OperatorFunctionId.Operator);
  break;

case UnqualifiedIdKind::IK_LiteralOperatorId:
  TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier);
  break;

default:
  return TNK_Non_template;
}

QualType ObjectType = ObjectTypePtr.get();

AssumedTemplateKind AssumedTemplate;
LookupResult R(*this, TName, Name.getBeginLoc(), LookupOrdinaryName);
if (LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
                       MemberOfUnknownSpecialization, SourceLocation(),
                       &AssumedTemplate,
                       /*AllowTypoCorrection=*/!Disambiguation))
  return TNK_Non_template;

if (AssumedTemplate != AssumedTemplateKind::None) {
  TemplateResult = TemplateTy::make(Context.getAssumedTemplateName(TName));
  // Let the parser know whether we found nothing or found functions; if we
  // found nothing, we want to more carefully check whether this is actually
  // a function template name versus some other kind of undeclared identifier.
  return AssumedTemplate == AssumedTemplateKind::FoundNothing
             ? TNK_Undeclared_template
             : TNK_Function_template;
}

if (R.empty())
  return TNK_Non_template;

NamedDecl *D = nullptr;
if (R.isAmbiguous()) {
  // If we got an ambiguity involving a non-function template, treat this
  // as a template name, and pick an arbitrary template for error recovery.
  bool AnyFunctionTemplates = false;
  for (NamedDecl *FoundD : R) {
    if (NamedDecl *FoundTemplate = getAsTemplateNameDecl(FoundD)) {
      if (isa<FunctionTemplateDecl>(FoundTemplate))
        AnyFunctionTemplates = true;
      else {
        D = FoundTemplate;
        break;
      }
    }
  }

  // If we didn't find any templates at all, this isn't a template name.
  // Leave the ambiguity for a later lookup to diagnose.
  if (!D && !AnyFunctionTemplates) {
    R.suppressDiagnostics();
    return TNK_Non_template;
  }

  // If the only templates were function templates, filter out the rest.
  // We'll diagnose the ambiguity later.
  if (!D)
    FilterAcceptableTemplateNames(R);
}

// At this point, we have either picked a single template name declaration D
// or we have a non-empty set of results R containing either one template name
// declaration or a set of function templates.

TemplateName Template;
TemplateNameKind TemplateKind;

unsigned ResultCount = R.end() - R.begin();
if (!D && ResultCount > 1) {
  // We assume that we'll preserve the qualifier from a function
  // template name in other ways.
  Template = Context.getOverloadedTemplateName(R.begin(), R.end());
  TemplateKind = TNK_Function_template;

  // We'll do this lookup again later.
  R.suppressDiagnostics();
} else {
  if (!D) {
    D = getAsTemplateNameDecl(*R.begin());
    assert(D && "unambiguous result is not a template name")((void)0);
  }

  if (isa<UnresolvedUsingValueDecl>(D)) {
    // We don't yet know whether this is a template-name or not.
    MemberOfUnknownSpecialization = true;
    return TNK_Non_template;
  }

  TemplateDecl *TD = cast<TemplateDecl>(D);

  if (SS.isSet() && !SS.isInvalid()) {
    NestedNameSpecifier *Qualifier = SS.getScopeRep();
    Template = Context.getQualifiedTemplateName(Qualifier,
                                                hasTemplateKeyword, TD);
  } else {
    Template = TemplateName(TD);
  }

  if (isa<FunctionTemplateDecl>(TD)) {
    TemplateKind = TNK_Function_template;

    // We'll do this lookup again later.
    R.suppressDiagnostics();
  } else {
    assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||((void)0)
           isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||((void)0)
           isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD))((void)0);
    TemplateKind =
        isa<VarTemplateDecl>(TD) ? TNK_Var_template :
        isa<ConceptDecl>(TD) ? TNK_Concept_template :
        TNK_Type_template;
  }
}

TemplateResult = TemplateTy::make(Template);
return TemplateKind;
310}

312bool Sema::isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
                              SourceLocation NameLoc,
                              ParsedTemplateTy *Template) {
CXXScopeSpec SS;
bool MemberOfUnknownSpecialization = false;

// We could use redeclaration lookup here, but we don't need to: the
// syntactic form of a deduction guide is enough to identify it even
// if we can't look up the template name at all.
LookupResult R(*this, DeclarationName(&Name), NameLoc, LookupOrdinaryName);
if (LookupTemplateName(R, S, SS, /*ObjectType*/ QualType(),
                       /*EnteringContext*/ false,
                       MemberOfUnknownSpecialization))
  return false;

if (R.empty()) return false;
if (R.isAmbiguous()) {
  // FIXME: Diagnose an ambiguity if we find at least one template.
  R.suppressDiagnostics();
  return false;
}

// We only treat template-names that name type templates as valid deduction
// guide names.
TemplateDecl *TD = R.getAsSingle<TemplateDecl>();
if (!TD || !getAsTypeTemplateDecl(TD))
  return false;

if (Template)
  *Template = TemplateTy::make(TemplateName(TD));
return true;
343}

345bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
                                     SourceLocation IILoc,
                                     Scope *S,
                                     const CXXScopeSpec *SS,
                                     TemplateTy &SuggestedTemplate,
                                     TemplateNameKind &SuggestedKind) {
// We can't recover unless there's a dependent scope specifier preceding the
// template name.
// FIXME: Typo correction?
if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
    computeDeclContext(*SS))
  return false;

// The code is missing a 'template' keyword prior to the dependent template
// name.
NestedNameSpecifier *Qualifier = (NestedNameSpecifier*)SS->getScopeRep();
Diag(IILoc, diag::err_template_kw_missing)
  << Qualifier << II.getName()
  << FixItHint::CreateInsertion(IILoc, "template ");
SuggestedTemplate
  = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
SuggestedKind = TNK_Dependent_template_name;
return true;
368}

370bool Sema::LookupTemplateName(LookupResult &Found,
                            Scope *S, CXXScopeSpec &SS,
                            QualType ObjectType,
                            bool EnteringContext,
                            bool &MemberOfUnknownSpecialization,
                            RequiredTemplateKind RequiredTemplate,
                            AssumedTemplateKind *ATK,
                            bool AllowTypoCorrection) {
if (ATK6.1
'ATK' is null
1
'ATK' is null
1
'ATK' is null
1
'ATK' is null
1
'ATK' is null
)
7
←
Taking false branch→
  *ATK = AssumedTemplateKind::None;

if (SS.isInvalid())
8
←
Calling 'CXXScopeSpec::isInvalid'→
10
←
Returning from 'CXXScopeSpec::isInvalid'→
11
←
Taking false branch→
  return true;

Found.setTemplateNameLookup(true);

// Determine where to perform name lookup
MemberOfUnknownSpecialization = false;
DeclContext *LookupCtx = nullptr;
bool IsDependent = false;
if (!ObjectType.isNull()) {
12
←
Calling 'QualType::isNull'→
26
←
Returning from 'QualType::isNull'→
27
←
Taking false branch→
  // 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.isEmpty() && "ObjectType and scope specifier cannot coexist")((void)0);
  LookupCtx = computeDeclContext(ObjectType);
  IsDependent = !LookupCtx && ObjectType->isDependentType();
  assert((IsDependent || !ObjectType->isIncompleteType() ||((void)0)
          ObjectType->castAs<TagType>()->isBeingDefined()) &&((void)0)
         "Caller should have completed object type")((void)0);

  // Template names cannot appear inside an Objective-C class or object type
  // or a vector type.
  //
  // FIXME: This is wrong. For example:
  //
  //   template<typename T> using Vec = T __attribute__((ext_vector_type(4)));
  //   Vec<int> vi;
  //   vi.Vec<int>::~Vec<int>();
  //
  // ... should be accepted but we will not treat 'Vec' as a template name
  // here. The right thing to do would be to check if the name is a valid
  // vector component name, and look up a template name if not. And similarly
  // for lookups into Objective-C class and object types, where the same
  // problem can arise.
  if (ObjectType->isObjCObjectOrInterfaceType() ||
      ObjectType->isVectorType()) {
    Found.clear();
    return false;
  }
} else if (SS.isNotEmpty()) {
28
←
Calling 'CXXScopeSpec::isNotEmpty'→
34
←
Returning from 'CXXScopeSpec::isNotEmpty'→
35
←
Taking true branch→
  // 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, EnteringContext);
  IsDependent = !LookupCtx && isDependentScopeSpecifier(SS);
36
←
Assuming 'LookupCtx' is non-null→

  // The declaration context must be complete.
  if (LookupCtx36.1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
 && RequireCompleteDeclContext(SS, LookupCtx))
37
←
Assuming the condition is false→
38
←
Taking false branch→
    return true;
}

bool ObjectTypeSearchedInScope = false;
bool AllowFunctionTemplatesInLookup = true;
if (LookupCtx38.1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
1
'LookupCtx' is non-null
) {
39
←
Taking true branch→
  // 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.
  LookupQualifiedName(Found, LookupCtx);

  // FIXME: The C++ standard does not clearly specify what happens in the
  // case where the object type is dependent, and implementations vary. In
  // Clang, we treat a name after a . or -> as a template-name if lookup
  // finds a non-dependent member or member of the current instantiation that
  // is a type template, or finds no such members and lookup in the context
  // of the postfix-expression finds a type template. In the latter case, the
  // name is nonetheless dependent, and we may resolve it to a member of an
  // unknown specialization when we come to instantiate the template.
  IsDependent |= Found.wasNotFoundInCurrentInstantiation();
}

if (SS.isEmpty() && (ObjectType.isNull() || Found.empty())) {
  // C++ [basic.lookup.classref]p1:
  //   In a class member access expression (5.2.5), if the . or -> token is
  //   immediately followed by an identifier followed by a <, the
  //   identifier must be looked up to determine whether the < is the
  //   beginning of a template argument list (14.2) or a less-than operator.
  //   The identifier is first looked up in the class of the object
  //   expression. If the identifier is not found, it is then looked up in
  //   the context of the entire postfix-expression and shall name a class
  //   template.
  if (S)
    LookupName(Found, S);

  if (!ObjectType.isNull()) {
    //  FIXME: We should filter out all non-type templates here, particularly
    //  variable templates and concepts. But the exclusion of alias templates
    //  and template template parameters is a wording defect.
    AllowFunctionTemplatesInLookup = false;
    ObjectTypeSearchedInScope = true;
  }

  IsDependent |= Found.wasNotFoundInCurrentInstantiation();
}

if (Found.isAmbiguous())
40
←
Assuming the condition is true→
41
←
Taking true branch→
  return false;
42
←
Returning zero, which participates in a condition later→

if (ATK && SS.isEmpty() && ObjectType.isNull() &&
    !RequiredTemplate.hasTemplateKeyword()) {
  // C++2a [temp.names]p2:
  //   A name is also considered to refer to a template if it is an
  //   unqualified-id followed by a < and name lookup finds either one or more
  //   functions or finds nothing.
  //
  // To keep our behavior consistent, we apply the "finds nothing" part in
  // all language modes, and diagnose the empty lookup in ActOnCallExpr if we
  // successfully form a call to an undeclared template-id.
  bool AllFunctions =
      getLangOpts().CPlusPlus20 &&
      std::all_of(Found.begin(), Found.end(), [](NamedDecl *ND) {
        return isa<FunctionDecl>(ND->getUnderlyingDecl());
      });
  if (AllFunctions || (Found.empty() && !IsDependent)) {
    // If lookup found any functions, or if this is a name that can only be
    // used for a function, then strongly assume this is a function
    // template-id.
    *ATK = (Found.empty() && Found.getLookupName().isIdentifier())
               ? AssumedTemplateKind::FoundNothing
               : AssumedTemplateKind::FoundFunctions;
    Found.clear();
    return false;
  }
}

if (Found.empty() && !IsDependent && AllowTypoCorrection) {
  // If we did not find any names, and this is not a disambiguation, attempt
  // to correct any typos.
  DeclarationName Name = Found.getLookupName();
  Found.clear();
  // Simple filter callback that, for keywords, only accepts the C++ *_cast
  DefaultFilterCCC FilterCCC{};
  FilterCCC.WantTypeSpecifiers = false;
  FilterCCC.WantExpressionKeywords = false;
  FilterCCC.WantRemainingKeywords = false;
  FilterCCC.WantCXXNamedCasts = true;
  if (TypoCorrection Corrected =
          CorrectTypo(Found.getLookupNameInfo(), Found.getLookupKind(), S,
                      &SS, FilterCCC, CTK_ErrorRecovery, LookupCtx)) {
    if (auto *ND = Corrected.getFoundDecl())
      Found.addDecl(ND);
    FilterAcceptableTemplateNames(Found);
    if (Found.isAmbiguous()) {
      Found.clear();
    } else if (!Found.empty()) {
      Found.setLookupName(Corrected.getCorrection());
      if (LookupCtx) {
        std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
        bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
                                Name.getAsString() == CorrectedStr;
        diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
                                  << Name << LookupCtx << DroppedSpecifier
                                  << SS.getRange());
      } else {
        diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
      }
    }
  }
}

NamedDecl *ExampleLookupResult =
    Found.empty() ? nullptr : Found.getRepresentativeDecl();
FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
if (Found.empty()) {
  if (IsDependent) {
    MemberOfUnknownSpecialization = true;
    return false;
  }

  // If a 'template' keyword was used, a lookup that finds only non-template
  // names is an error.
  if (ExampleLookupResult && RequiredTemplate) {
    Diag(Found.getNameLoc(), diag::err_template_kw_refers_to_non_template)
        << Found.getLookupName() << SS.getRange()
        << RequiredTemplate.hasTemplateKeyword()
        << RequiredTemplate.getTemplateKeywordLoc();
    Diag(ExampleLookupResult->getUnderlyingDecl()->getLocation(),
         diag::note_template_kw_refers_to_non_template)
        << Found.getLookupName();
    return true;
  }

  return false;
}

if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope &&
    !getLangOpts().CPlusPlus11) {
  // C++03 [basic.lookup.classref]p1:
  //   [...] If the lookup in the class of the object expression finds a
  //   template, the name is also looked up in the context of the entire
  //   postfix-expression and [...]
  //
  // Note: C++11 does not perform this second lookup.
  LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
                          LookupOrdinaryName);
  FoundOuter.setTemplateNameLookup(true);
  LookupName(FoundOuter, S);
  // FIXME: We silently accept an ambiguous lookup here, in violation of
  // [basic.lookup]/1.
  FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false);

  NamedDecl *OuterTemplate;
  if (FoundOuter.empty()) {
    //   - if the name is not found, the name found in the class of the
    //     object expression is used, otherwise
  } else if (FoundOuter.isAmbiguous() || !FoundOuter.isSingleResult() ||
             !(OuterTemplate =
                   getAsTemplateNameDecl(FoundOuter.getFoundDecl()))) {
    //   - if the name is found in the context of the entire
    //     postfix-expression and does not name a class template, the name
    //     found in the class of the object expression is used, otherwise
    FoundOuter.clear();
  } else if (!Found.isSuppressingDiagnostics()) {
    //   - if the name found is a class template, it must refer to the same
    //     entity as the one found in the class of the object expression,
    //     otherwise the program is ill-formed.
    if (!Found.isSingleResult() ||
        getAsTemplateNameDecl(Found.getFoundDecl())->getCanonicalDecl() !=
            OuterTemplate->getCanonicalDecl()) {
      Diag(Found.getNameLoc(),
           diag::ext_nested_name_member_ref_lookup_ambiguous)
        << Found.getLookupName()
        << ObjectType;
      Diag(Found.getRepresentativeDecl()->getLocation(),
           diag::note_ambig_member_ref_object_type)
        << ObjectType;
      Diag(FoundOuter.getFoundDecl()->getLocation(),
           diag::note_ambig_member_ref_scope);

      // Recover by taking the template that we found in the object
      // expression's type.
    }
  }
}

return false;
615}

617void Sema::diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
                                            SourceLocation Less,
                                            SourceLocation Greater) {
if (TemplateName.isInvalid())
  return;

DeclarationNameInfo NameInfo;
CXXScopeSpec SS;
LookupNameKind LookupKind;

DeclContext *LookupCtx = nullptr;
NamedDecl *Found = nullptr;
bool MissingTemplateKeyword = false;

// Figure out what name we looked up.
if (auto *DRE = dyn_cast<DeclRefExpr>(TemplateName.get())) {
  NameInfo = DRE->getNameInfo();
  SS.Adopt(DRE->getQualifierLoc());
  LookupKind = LookupOrdinaryName;
  Found = DRE->getFoundDecl();
} else if (auto *ME = dyn_cast<MemberExpr>(TemplateName.get())) {
  NameInfo = ME->getMemberNameInfo();
  SS.Adopt(ME->getQualifierLoc());
  LookupKind = LookupMemberName;
  LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
  Found = ME->getMemberDecl();
} else if (auto *DSDRE =
               dyn_cast<DependentScopeDeclRefExpr>(TemplateName.get())) {
  NameInfo = DSDRE->getNameInfo();
  SS.Adopt(DSDRE->getQualifierLoc());
  MissingTemplateKeyword = true;
} else if (auto *DSME =
               dyn_cast<CXXDependentScopeMemberExpr>(TemplateName.get())) {
  NameInfo = DSME->getMemberNameInfo();
  SS.Adopt(DSME->getQualifierLoc());
  MissingTemplateKeyword = true;
} else {
  llvm_unreachable("unexpected kind of potential template name")__builtin_unreachable();
}

// If this is a dependent-scope lookup, diagnose that the 'template' keyword
// was missing.
if (MissingTemplateKeyword) {
  Diag(NameInfo.getBeginLoc(), diag::err_template_kw_missing)
      << "" << NameInfo.getName().getAsString() << SourceRange(Less, Greater);
  return;
}

// Try to correct the name by looking for templates and C++ named casts.
struct TemplateCandidateFilter : CorrectionCandidateCallback {
  Sema &S;
  TemplateCandidateFilter(Sema &S) : S(S) {
    WantTypeSpecifiers = false;
    WantExpressionKeywords = false;
    WantRemainingKeywords = false;
    WantCXXNamedCasts = true;
  };
  bool ValidateCandidate(const TypoCorrection &Candidate) override {
    if (auto *ND = Candidate.getCorrectionDecl())
      return S.getAsTemplateNameDecl(ND);
    return Candidate.isKeyword();
  }

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

DeclarationName Name = NameInfo.getName();
TemplateCandidateFilter CCC(*this);
if (TypoCorrection Corrected = CorrectTypo(NameInfo, LookupKind, S, &SS, CCC,
                                           CTK_ErrorRecovery, LookupCtx)) {
  auto *ND = Corrected.getFoundDecl();
  if (ND)
    ND = getAsTemplateNameDecl(ND);
  if (ND || Corrected.isKeyword()) {
    if (LookupCtx) {
      std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
      bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
                              Name.getAsString() == CorrectedStr;
      diagnoseTypo(Corrected,
                   PDiag(diag::err_non_template_in_member_template_id_suggest)
                       << Name << LookupCtx << DroppedSpecifier
                       << SS.getRange(), false);
    } else {
      diagnoseTypo(Corrected,
                   PDiag(diag::err_non_template_in_template_id_suggest)
                       << Name, false);
    }
    if (Found)
      Diag(Found->getLocation(),
           diag::note_non_template_in_template_id_found);
    return;
  }
}

Diag(NameInfo.getLoc(), diag::err_non_template_in_template_id)
  << Name << SourceRange(Less, Greater);
if (Found)
  Diag(Found->getLocation(), diag::note_non_template_in_template_id_found);
717}

719/// ActOnDependentIdExpression - Handle a dependent id-expression that
720/// was just parsed.  This is only possible with an explicit scope
721/// specifier naming a dependent type.
722ExprResult
723Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
                               SourceLocation TemplateKWLoc,
                               const DeclarationNameInfo &NameInfo,
                               bool isAddressOfOperand,
                         const TemplateArgumentListInfo *TemplateArgs) {
DeclContext *DC = getFunctionLevelDeclContext();

// C++11 [expr.prim.general]p12:
//   An id-expression that denotes a non-static data member or non-static
//   member function of a class can only be used:
//   (...)
//   - if that id-expression denotes a non-static data member and it
//     appears in an unevaluated operand.
//
// If this might be the case, form a DependentScopeDeclRefExpr instead of a
// CXXDependentScopeMemberExpr. The former can instantiate to either
// DeclRefExpr or MemberExpr depending on lookup results, while the latter is
// always a MemberExpr.
bool MightBeCxx11UnevalField =
    getLangOpts().CPlusPlus11 && isUnevaluatedContext();

// Check if the nested name specifier is an enum type.
bool IsEnum = false;
if (NestedNameSpecifier *NNS = SS.getScopeRep())
  IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());

if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
    isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
  QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType();

  // Since the 'this' expression is synthesized, we don't need to
  // perform the double-lookup check.
  NamedDecl *FirstQualifierInScope = nullptr;

  return CXXDependentScopeMemberExpr::Create(
      Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
      /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
      FirstQualifierInScope, NameInfo, TemplateArgs);
}

return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
764}

766ExprResult
767Sema::BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
                              SourceLocation TemplateKWLoc,
                              const DeclarationNameInfo &NameInfo,
                              const TemplateArgumentListInfo *TemplateArgs) {
// DependentScopeDeclRefExpr::Create requires a valid QualifierLoc
NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
if (!QualifierLoc)
  return ExprError();

return DependentScopeDeclRefExpr::Create(
    Context, QualifierLoc, TemplateKWLoc, NameInfo, TemplateArgs);
778}


781/// Determine whether we would be unable to instantiate this template (because
782/// it either has no definition, or is in the process of being instantiated).
783bool Sema::DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
                                        NamedDecl *Instantiation,
                                        bool InstantiatedFromMember,
                                        const NamedDecl *Pattern,
                                        const NamedDecl *PatternDef,
                                        TemplateSpecializationKind TSK,
                                        bool Complain /*= true*/) {
assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||((void)0)
       isa<VarDecl>(Instantiation))((void)0);

bool IsEntityBeingDefined = false;
if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
  IsEntityBeingDefined = TD->isBeingDefined();

if (PatternDef && !IsEntityBeingDefined) {
  NamedDecl *SuggestedDef = nullptr;
  if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
                            /*OnlyNeedComplete*/false)) {
    // If we're allowed to diagnose this and recover, do so.
    bool Recover = Complain && !isSFINAEContext();
    if (Complain)
      diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
                            Sema::MissingImportKind::Definition, Recover);
    return !Recover;
  }
  return false;
}

if (!Complain || (PatternDef && PatternDef->isInvalidDecl()))
  return true;

llvm::Optional<unsigned> Note;
QualType InstantiationTy;
if (TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
  InstantiationTy = Context.getTypeDeclType(TD);
if (PatternDef) {
  Diag(PointOfInstantiation,
       diag::err_template_instantiate_within_definition)
    << /*implicit|explicit*/(TSK != TSK_ImplicitInstantiation)
    << InstantiationTy;
  // Not much point in noting the template declaration here, since
  // we're lexically inside it.
  Instantiation->setInvalidDecl();
} else if (InstantiatedFromMember) {
  if (isa<FunctionDecl>(Instantiation)) {
    Diag(PointOfInstantiation,
         diag::err_explicit_instantiation_undefined_member)
      << /*member function*/ 1 << Instantiation->getDeclName()
      << Instantiation->getDeclContext();
    Note = diag::note_explicit_instantiation_here;
  } else {
    assert(isa<TagDecl>(Instantiation) && "Must be a TagDecl!")((void)0);
    Diag(PointOfInstantiation,
         diag::err_implicit_instantiate_member_undefined)
      << InstantiationTy;
    Note = diag::note_member_declared_at;
  }
} else {
  if (isa<FunctionDecl>(Instantiation)) {
    Diag(PointOfInstantiation,
         diag::err_explicit_instantiation_undefined_func_template)
      << Pattern;
    Note = diag::note_explicit_instantiation_here;
  } else if (isa<TagDecl>(Instantiation)) {
    Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
      << (TSK != TSK_ImplicitInstantiation)
      << InstantiationTy;
    Note = diag::note_template_decl_here;
  } else {
    assert(isa<VarDecl>(Instantiation) && "Must be a VarDecl!")((void)0);
    if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
      Diag(PointOfInstantiation,
           diag::err_explicit_instantiation_undefined_var_template)
        << Instantiation;
      Instantiation->setInvalidDecl();
    } else
      Diag(PointOfInstantiation,
           diag::err_explicit_instantiation_undefined_member)
        << /*static data member*/ 2 << Instantiation->getDeclName()
        << Instantiation->getDeclContext();
    Note = diag::note_explicit_instantiation_here;
  }
}
if (Note) // Diagnostics were emitted.
  Diag(Pattern->getLocation(), Note.getValue());

// In general, Instantiation isn't marked invalid to get more than one
// error for multiple undefined instantiations. But the code that does
// explicit declaration -> explicit definition conversion can't handle
// invalid declarations, so mark as invalid in that case.
if (TSK == TSK_ExplicitInstantiationDeclaration)
  Instantiation->setInvalidDecl();
return true;
876}

878/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
879/// that the template parameter 'PrevDecl' is being shadowed by a new
880/// declaration at location Loc. Returns true to indicate that this is
881/// an error, and false otherwise.
882void Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
assert(PrevDecl->isTemplateParameter() && "Not a template parameter")((void)0);

// C++ [temp.local]p4:
//   A template-parameter shall not be redeclared within its
//   scope (including nested scopes).
//
// Make this a warning when MSVC compatibility is requested.
unsigned DiagId = getLangOpts().MSVCCompat ? diag::ext_template_param_shadow
                                           : diag::err_template_param_shadow;
Diag(Loc, DiagId) << cast<NamedDecl>(PrevDecl)->getDeclName();
Diag(PrevDecl->getLocation(), diag::note_template_param_here);
894}

896/// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
897/// the parameter D to reference the templated declaration and return a pointer
898/// to the template declaration. Otherwise, do nothing to D and return null.
899TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) {
if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
  D = Temp->getTemplatedDecl();
  return Temp;
}
return nullptr;
905}

907ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
                                           SourceLocation EllipsisLoc) const {
assert(Kind == Template &&((void)0)
       "Only template template arguments can be pack expansions here")((void)0);
assert(getAsTemplate().get().containsUnexpandedParameterPack() &&((void)0)
       "Template template argument pack expansion without packs")((void)0);
ParsedTemplateArgument Result(*this);
Result.EllipsisLoc = EllipsisLoc;
return Result;
916}

918static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
                                          const ParsedTemplateArgument &Arg) {

switch (Arg.getKind()) {
case ParsedTemplateArgument::Type: {
  TypeSourceInfo *DI;
  QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
  if (!DI)
    DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
  return TemplateArgumentLoc(TemplateArgument(T), DI);
}

case ParsedTemplateArgument::NonType: {
  Expr *E = static_cast<Expr *>(Arg.getAsExpr());
  return TemplateArgumentLoc(TemplateArgument(E), E);
}

case ParsedTemplateArgument::Template: {
  TemplateName Template = Arg.getAsTemplate().get();
  TemplateArgument TArg;
  if (Arg.getEllipsisLoc().isValid())
    TArg = TemplateArgument(Template, Optional<unsigned int>());
  else
    TArg = Template;
  return TemplateArgumentLoc(
      SemaRef.Context, TArg,
      Arg.getScopeSpec().getWithLocInContext(SemaRef.Context),
      Arg.getLocation(), Arg.getEllipsisLoc());
}
}

llvm_unreachable("Unhandled parsed template argument")__builtin_unreachable();
950}

952/// Translates template arguments as provided by the parser
953/// into template arguments used by semantic analysis.
954void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn,
                                    TemplateArgumentListInfo &TemplateArgs) {
for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
 TemplateArgs.addArgument(translateTemplateArgument(*this,
                                                    TemplateArgsIn[I]));
959}

961static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S,
                                               SourceLocation Loc,
                                               IdentifierInfo *Name) {
NamedDecl *PrevDecl = SemaRef.LookupSingleName(
    S, Name, Loc, Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration);
if (PrevDecl && PrevDecl->isTemplateParameter())
  SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
968}

970/// Convert a parsed type into a parsed template argument. This is mostly
971/// trivial, except that we may have parsed a C++17 deduced class template
972/// specialization type, in which case we should form a template template
973/// argument instead of a type template argument.
974ParsedTemplateArgument Sema::ActOnTemplateTypeArgument(TypeResult ParsedType) {
TypeSourceInfo *TInfo;
QualType T = GetTypeFromParser(ParsedType.get(), &TInfo);
if (T.isNull())
  return ParsedTemplateArgument();
assert(TInfo && "template argument with no location")((void)0);

// If we might have formed a deduced template specialization type, convert
// it to a template template argument.
if (getLangOpts().CPlusPlus17) {
  TypeLoc TL = TInfo->getTypeLoc();
  SourceLocation EllipsisLoc;
  if (auto PET = TL.getAs<PackExpansionTypeLoc>()) {
    EllipsisLoc = PET.getEllipsisLoc();
    TL = PET.getPatternLoc();
  }

  CXXScopeSpec SS;
  if (auto ET = TL.getAs<ElaboratedTypeLoc>()) {
    SS.Adopt(ET.getQualifierLoc());
    TL = ET.getNamedTypeLoc();
  }

  if (auto DTST = TL.getAs<DeducedTemplateSpecializationTypeLoc>()) {
    TemplateName Name = DTST.getTypePtr()->getTemplateName();
    if (SS.isSet())
      Name = Context.getQualifiedTemplateName(SS.getScopeRep(),
                                              /*HasTemplateKeyword*/ false,
                                              Name.getAsTemplateDecl());
    ParsedTemplateArgument Result(SS, TemplateTy::make(Name),
                                  DTST.getTemplateNameLoc());
    if (EllipsisLoc.isValid())
      Result = Result.getTemplatePackExpansion(EllipsisLoc);
    return Result;
  }
}

// This is a normal type template argument. Note, if the type template
// argument is an injected-class-name for a template, it has a dual nature
// and can be used as either a type or a template. We handle that in
// convertTypeTemplateArgumentToTemplate.
return ParsedTemplateArgument(ParsedTemplateArgument::Type,
                              ParsedType.get().getAsOpaquePtr(),
                              TInfo->getTypeLoc().getBeginLoc());
1018}

1020/// ActOnTypeParameter - Called when a C++ template type parameter
1021/// (e.g., "typename T") has been parsed. Typename specifies whether
1022/// the keyword "typename" was used to declare the type parameter
1023/// (otherwise, "class" was used), and KeyLoc is the location of the
1024/// "class" or "typename" keyword. ParamName is the name of the
1025/// parameter (NULL indicates an unnamed template parameter) and
1026/// ParamNameLoc is the location of the parameter name (if any).
1027/// If the type parameter has a default argument, it will be added
1028/// later via ActOnTypeParameterDefault.
1029NamedDecl *Sema::ActOnTypeParameter(Scope *S, bool Typename,
                                  SourceLocation EllipsisLoc,
                                  SourceLocation KeyLoc,
                                  IdentifierInfo *ParamName,
                                  SourceLocation ParamNameLoc,
                                  unsigned Depth, unsigned Position,
                                  SourceLocation EqualLoc,
                                  ParsedType DefaultArg,
                                  bool HasTypeConstraint) {
assert(S->isTemplateParamScope() &&((void)0)
       "Template type parameter not in template parameter scope!")((void)0);

bool IsParameterPack = EllipsisLoc.isValid();
TemplateTypeParmDecl *Param
  = TemplateTypeParmDecl::Create(Context, Context.getTranslationUnitDecl(),
                                 KeyLoc, ParamNameLoc, Depth, Position,
                                 ParamName, Typename, IsParameterPack,
                                 HasTypeConstraint);
Param->setAccess(AS_public);

if (Param->isParameterPack())
  if (auto *LSI = getEnclosingLambda())
    LSI->LocalPacks.push_back(Param);

if (ParamName) {
  maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);

  // Add the template parameter into the current scope.
  S->AddDecl(Param);
  IdResolver.AddDecl(Param);
}

// C++0x [temp.param]p9:
//   A default template-argument may be specified for any kind of
//   template-parameter that is not a template parameter pack.
if (DefaultArg && IsParameterPack) {
  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
  DefaultArg = nullptr;
}

// Handle the default argument, if provided.
if (DefaultArg) {
  TypeSourceInfo *DefaultTInfo;
  GetTypeFromParser(DefaultArg, &DefaultTInfo);

  assert(DefaultTInfo && "expected source information for type")((void)0);

  // Check for unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(ParamNameLoc, DefaultTInfo,
                                      UPPC_DefaultArgument))
    return Param;

  // Check the template argument itself.
  if (CheckTemplateArgument(DefaultTInfo)) {
    Param->setInvalidDecl();
    return Param;
  }

  Param->setDefaultArgument(DefaultTInfo);
}

return Param;
1091}

1093/// Convert the parser's template argument list representation into our form.
1094static TemplateArgumentListInfo
1095makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId) {
TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
                                      TemplateId.RAngleLoc);
ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
                                   TemplateId.NumArgs);
S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
return TemplateArgs;
1102}

1104bool Sema::ActOnTypeConstraint(const CXXScopeSpec &SS,
                             TemplateIdAnnotation *TypeConstr,
                             TemplateTypeParmDecl *ConstrainedParameter,
                             SourceLocation EllipsisLoc) {
return BuildTypeConstraint(SS, TypeConstr, ConstrainedParameter, EllipsisLoc,
                           false);
1110}

1112bool Sema::BuildTypeConstraint(const CXXScopeSpec &SS,
                             TemplateIdAnnotation *TypeConstr,
                             TemplateTypeParmDecl *ConstrainedParameter,
                             SourceLocation EllipsisLoc,
                             bool AllowUnexpandedPack) {
TemplateName TN = TypeConstr->Template.get();
ConceptDecl *CD = cast<ConceptDecl>(TN.getAsTemplateDecl());

// C++2a [temp.param]p4:
//     [...] The concept designated by a type-constraint shall be a type
//     concept ([temp.concept]).
if (!CD->isTypeConcept()) {
  Diag(TypeConstr->TemplateNameLoc,
       diag::err_type_constraint_non_type_concept);
  return true;
}

bool WereArgsSpecified = TypeConstr->LAngleLoc.isValid();

if (!WereArgsSpecified &&
    CD->getTemplateParameters()->getMinRequiredArguments() > 1) {
  Diag(TypeConstr->TemplateNameLoc,
       diag::err_type_constraint_missing_arguments) << CD;
  return true;
}

DeclarationNameInfo ConceptName(DeclarationName(TypeConstr->Name),
                                TypeConstr->TemplateNameLoc);

TemplateArgumentListInfo TemplateArgs;
if (TypeConstr->LAngleLoc.isValid()) {
  TemplateArgs =
      makeTemplateArgumentListInfo(*this, *TypeConstr);

  if (EllipsisLoc.isInvalid() && !AllowUnexpandedPack) {
    for (TemplateArgumentLoc Arg : TemplateArgs.arguments()) {
      if (DiagnoseUnexpandedParameterPack(Arg, UPPC_TypeConstraint))
        return true;
    }
  }
}
return AttachTypeConstraint(
    SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc(),
    ConceptName, CD,
    TypeConstr->LAngleLoc.isValid() ? &TemplateArgs : nullptr,
    ConstrainedParameter, EllipsisLoc);
1158}

1160template<typename ArgumentLocAppender>
1161static ExprResult formImmediatelyDeclaredConstraint(
  Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo,
  ConceptDecl *NamedConcept, SourceLocation LAngleLoc,
  SourceLocation RAngleLoc, QualType ConstrainedType,
  SourceLocation ParamNameLoc, ArgumentLocAppender Appender,
  SourceLocation EllipsisLoc) {

TemplateArgumentListInfo ConstraintArgs;
ConstraintArgs.addArgument(
  S.getTrivialTemplateArgumentLoc(TemplateArgument(ConstrainedType),
                                  /*NTTPType=*/QualType(), ParamNameLoc));

ConstraintArgs.setRAngleLoc(RAngleLoc);
ConstraintArgs.setLAngleLoc(LAngleLoc);
Appender(ConstraintArgs);

// C++2a [temp.param]p4:
//     [...] This constraint-expression E is called the immediately-declared
//     constraint of T. [...]
CXXScopeSpec SS;
SS.Adopt(NS);
ExprResult ImmediatelyDeclaredConstraint = S.CheckConceptTemplateId(
    SS, /*TemplateKWLoc=*/SourceLocation(), NameInfo,
    /*FoundDecl=*/NamedConcept, NamedConcept, &ConstraintArgs);
if (ImmediatelyDeclaredConstraint.isInvalid() || !EllipsisLoc.isValid())
  return ImmediatelyDeclaredConstraint;

// C++2a [temp.param]p4:
//     [...] If T is not a pack, then E is E', otherwise E is (E' && ...).
//
// We have the following case:
//
// template<typename T> concept C1 = true;
// template<C1... T> struct s1;
//
// The constraint: (C1<T> && ...)
//
// Note that the type of C1<T> is known to be 'bool', so we don't need to do
// any unqualified lookups for 'operator&&' here.
return S.BuildCXXFoldExpr(/*UnqualifiedLookup=*/nullptr,
                          /*LParenLoc=*/SourceLocation(),
                          ImmediatelyDeclaredConstraint.get(), BO_LAnd,
                          EllipsisLoc, /*RHS=*/nullptr,
                          /*RParenLoc=*/SourceLocation(),
                          /*NumExpansions=*/None);
1206}

1208/// Attach a type-constraint to a template parameter.
1209/// \returns true if an error occured. This can happen if the
1210/// immediately-declared constraint could not be formed (e.g. incorrect number
1211/// of arguments for the named concept).
1212bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
                              DeclarationNameInfo NameInfo,
                              ConceptDecl *NamedConcept,
                              const TemplateArgumentListInfo *TemplateArgs,
                              TemplateTypeParmDecl *ConstrainedParameter,
                              SourceLocation EllipsisLoc) {
// C++2a [temp.param]p4:
//     [...] If Q is of the form C<A1, ..., An>, then let E' be
//     C<T, A1, ..., An>. Otherwise, let E' be C<T>. [...]
const ASTTemplateArgumentListInfo *ArgsAsWritten =
  TemplateArgs ? ASTTemplateArgumentListInfo::Create(Context,
                                                     *TemplateArgs) : nullptr;

QualType ParamAsArgument(ConstrainedParameter->getTypeForDecl(), 0);

ExprResult ImmediatelyDeclaredConstraint =
    formImmediatelyDeclaredConstraint(
        *this, NS, NameInfo, NamedConcept,
        TemplateArgs ? TemplateArgs->getLAngleLoc() : SourceLocation(),
        TemplateArgs ? TemplateArgs->getRAngleLoc() : SourceLocation(),
        ParamAsArgument, ConstrainedParameter->getLocation(),
        [&] (TemplateArgumentListInfo &ConstraintArgs) {
          if (TemplateArgs)
            for (const auto &ArgLoc : TemplateArgs->arguments())
              ConstraintArgs.addArgument(ArgLoc);
        }, EllipsisLoc);
if (ImmediatelyDeclaredConstraint.isInvalid())
  return true;

ConstrainedParameter->setTypeConstraint(NS, NameInfo,
                                        /*FoundDecl=*/NamedConcept,
                                        NamedConcept, ArgsAsWritten,
                                        ImmediatelyDeclaredConstraint.get());
return false;
1246}

1248bool Sema::AttachTypeConstraint(AutoTypeLoc TL, NonTypeTemplateParmDecl *NTTP,
                              SourceLocation EllipsisLoc) {
if (NTTP->getType() != TL.getType() ||
    TL.getAutoKeyword() != AutoTypeKeyword::Auto) {
  Diag(NTTP->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
       diag::err_unsupported_placeholder_constraint)
     << NTTP->getTypeSourceInfo()->getTypeLoc().getSourceRange();
  return true;
}
// FIXME: Concepts: This should be the type of the placeholder, but this is
// unclear in the wording right now.
DeclRefExpr *Ref =
    BuildDeclRefExpr(NTTP, NTTP->getType(), VK_PRValue, NTTP->getLocation());
if (!Ref)
  return true;
ExprResult ImmediatelyDeclaredConstraint =
    formImmediatelyDeclaredConstraint(
        *this, TL.getNestedNameSpecifierLoc(), TL.getConceptNameInfo(),
        TL.getNamedConcept(), TL.getLAngleLoc(), TL.getRAngleLoc(),
        BuildDecltypeType(Ref, NTTP->getLocation()), NTTP->getLocation(),
        [&] (TemplateArgumentListInfo &ConstraintArgs) {
          for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
            ConstraintArgs.addArgument(TL.getArgLoc(I));
        }, EllipsisLoc);
if (ImmediatelyDeclaredConstraint.isInvalid() ||
   !ImmediatelyDeclaredConstraint.isUsable())
  return true;

NTTP->setPlaceholderTypeConstraint(ImmediatelyDeclaredConstraint.get());
return false;
1278}

1280/// Check that the type of a non-type template parameter is
1281/// well-formed.
1282///
1283/// \returns the (possibly-promoted) parameter type if valid;
1284/// otherwise, produces a diagnostic and returns a NULL type.
1285QualType Sema::CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
                                               SourceLocation Loc) {
if (TSI->getType()->isUndeducedType()) {
  // C++17 [temp.dep.expr]p3:
  //   An id-expression is type-dependent if it contains
  //    - an identifier associated by name lookup with a non-type
  //      template-parameter declared with a type that contains a
  //      placeholder type (7.1.7.4),
  TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
}

return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
1297}

1299/// Require the given type to be a structural type, and diagnose if it is not.
1300///
1301/// \return \c true if an error was produced.
1302bool Sema::RequireStructuralType(QualType T, SourceLocation Loc) {
if (T->isDependentType())
  return false;

if (RequireCompleteType(Loc, T, diag::err_template_nontype_parm_incomplete))
  return true;

if (T->isStructuralType())
  return false;

// Structural types are required to be object types or lvalue references.
if (T->isRValueReferenceType()) {
  Diag(Loc, diag::err_template_nontype_parm_rvalue_ref) << T;
  return true;
}

// Don't mention structural types in our diagnostic prior to C++20. Also,
// there's not much more we can say about non-scalar non-class types --
// because we can't see functions or arrays here, those can only be language
// extensions.
if (!getLangOpts().CPlusPlus20 ||
    (!T->isScalarType() && !T->isRecordType())) {
  Diag(Loc, diag::err_template_nontype_parm_bad_type) << T;
  return true;
}

// Structural types are required to be literal types.
if (RequireLiteralType(Loc, T, diag::err_template_nontype_parm_not_literal))
  return true;

Diag(Loc, diag::err_template_nontype_parm_not_structural) << T;

// Drill down into the reason why the class is non-structural.
while (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
  // All members are required to be public and non-mutable, and can't be of
  // rvalue reference type. Check these conditions first to prefer a "local"
  // reason over a more distant one.
  for (const FieldDecl *FD : RD->fields()) {
    if (FD->getAccess() != AS_public) {
      Diag(FD->getLocation(), diag::note_not_structural_non_public) << T << 0;
      return true;
    }
    if (FD->isMutable()) {
      Diag(FD->getLocation(), diag::note_not_structural_mutable_field) << T;
      return true;
    }
    if (FD->getType()->isRValueReferenceType()) {
      Diag(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)
          << T;
      return true;
    }
  }

  // All bases are required to be public.
  for (const auto &BaseSpec : RD->bases()) {
    if (BaseSpec.getAccessSpecifier() != AS_public) {
      Diag(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)
          << T << 1;
      return true;
    }
  }

  // All subobjects are required to be of structural types.
  SourceLocation SubLoc;
  QualType SubType;
  int Kind = -1;

  for (const FieldDecl *FD : RD->fields()) {
    QualType T = Context.getBaseElementType(FD->getType());
    if (!T->isStructuralType()) {
      SubLoc = FD->getLocation();
      SubType = T;
      Kind = 0;
      break;
    }
  }

  if (Kind == -1) {
    for (const auto &BaseSpec : RD->bases()) {
      QualType T = BaseSpec.getType();
      if (!T->isStructuralType()) {
        SubLoc = BaseSpec.getBaseTypeLoc();
        SubType = T;
        Kind = 1;
        break;
      }
    }
  }

  assert(Kind != -1 && "couldn't find reason why type is not structural")((void)0);
  Diag(SubLoc, diag::note_not_structural_subobject)
      << T << Kind << SubType;
  T = SubType;
  RD = T->getAsCXXRecordDecl();
}

return true;
1399}

1401QualType Sema::CheckNonTypeTemplateParameterType(QualType T,
                                               SourceLocation Loc) {
// We don't allow variably-modified types as the type of non-type template
// parameters.
if (T->isVariablyModifiedType()) {
  Diag(Loc, diag::err_variably_modified_nontype_template_param)
    << T;
  return QualType();
}

// C++ [temp.param]p4:
//
// A non-type template-parameter shall have one of the following
// (optionally cv-qualified) types:
//
//       -- integral or enumeration type,
if (T->isIntegralOrEnumerationType() ||
    //   -- pointer to object or pointer to function,
    T->isPointerType() ||
    //   -- lvalue reference to object or lvalue reference to function,
    T->isLValueReferenceType() ||
    //   -- pointer to member,
    T->isMemberPointerType() ||
    //   -- std::nullptr_t, or
    T->isNullPtrType() ||
    //   -- a type that contains a placeholder type.
    T->isUndeducedType()) {
  // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
  // are ignored when determining its type.
  return T.getUnqualifiedType();
}

// C++ [temp.param]p8:
//
//   A non-type template-parameter of type "array of T" or
//   "function returning T" is adjusted to be of type "pointer to
//   T" or "pointer to function returning T", respectively.
if (T->isArrayType() || T->isFunctionType())
  return Context.getDecayedType(T);

// If T is a dependent type, we can't do the check now, so we
// assume that it is well-formed. Note that stripping off the
// qualifiers here is not really correct if T turns out to be
// an array type, but we'll recompute the type everywhere it's
// used during instantiation, so that should be OK. (Using the
// qualified type is equally wrong.)
if (T->isDependentType())
  return T.getUnqualifiedType();

// C++20 [temp.param]p6:
//   -- a structural type
if (RequireStructuralType(T, Loc))
  return QualType();

if (!getLangOpts().CPlusPlus20) {
  // FIXME: Consider allowing structural types as an extension in C++17. (In
  // earlier language modes, the template argument evaluation rules are too
  // inflexible.)
  Diag(Loc, diag::err_template_nontype_parm_bad_structural_type) << T;
  return QualType();
}

Diag(Loc, diag::warn_cxx17_compat_template_nontype_parm_type) << T;
return T.getUnqualifiedType();
1465}

1467NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
                                        unsigned Depth,
                                        unsigned Position,
                                        SourceLocation EqualLoc,
                                        Expr *Default) {
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);

// Check that we have valid decl-specifiers specified.
auto CheckValidDeclSpecifiers = [this, &D] {
  // C++ [temp.param]
  // p1
  //   template-parameter:
  //     ...
  //     parameter-declaration
  // p2
  //   ... A storage class shall not be specified in a template-parameter
  //   declaration.
  // [dcl.typedef]p1:
  //   The typedef specifier [...] shall not be used in the decl-specifier-seq
  //   of a parameter-declaration
  const DeclSpec &DS = D.getDeclSpec();
  auto EmitDiag = [this](SourceLocation Loc) {
    Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
        << FixItHint::CreateRemoval(Loc);
  };
  if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified)
    EmitDiag(DS.getStorageClassSpecLoc());

  if (DS.getThreadStorageClassSpec() != TSCS_unspecified)
    EmitDiag(DS.getThreadStorageClassSpecLoc());

  // [dcl.inline]p1:
  //   The inline specifier can be applied only to the declaration or
  //   definition of a variable or function.

  if (DS.isInlineSpecified())
    EmitDiag(DS.getInlineSpecLoc());

  // [dcl.constexpr]p1:
  //   The constexpr specifier shall be applied only to the definition of a
  //   variable or variable template or the declaration of a function or
  //   function template.

  if (DS.hasConstexprSpecifier())
    EmitDiag(DS.getConstexprSpecLoc());

  // [dcl.fct.spec]p1:
  //   Function-specifiers can be used only in function declarations.

  if (DS.isVirtualSpecified())
    EmitDiag(DS.getVirtualSpecLoc());

  if (DS.hasExplicitSpecifier())
    EmitDiag(DS.getExplicitSpecLoc());

  if (DS.isNoreturnSpecified())
    EmitDiag(DS.getNoreturnSpecLoc());
};

CheckValidDeclSpecifiers();

if (TInfo->getType()->isUndeducedType()) {
  Diag(D.getIdentifierLoc(),
       diag::warn_cxx14_compat_template_nontype_parm_auto_type)
    << QualType(TInfo->getType()->getContainedAutoType(), 0);
}

assert(S->isTemplateParamScope() &&((void)0)
       "Non-type template parameter not in template parameter scope!")((void)0);
bool Invalid = false;

QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
if (T.isNull()) {
  T = Context.IntTy; // Recover with an 'int' type.
  Invalid = true;
}

CheckFunctionOrTemplateParamDeclarator(S, D);

IdentifierInfo *ParamName = D.getIdentifier();
bool IsParameterPack = D.hasEllipsis();
NonTypeTemplateParmDecl *Param = NonTypeTemplateParmDecl::Create(
    Context, Context.getTranslationUnitDecl(), D.getBeginLoc(),
    D.getIdentifierLoc(), Depth, Position, ParamName, T, IsParameterPack,
    TInfo);
Param->setAccess(AS_public);

if (AutoTypeLoc TL = TInfo->getTypeLoc().getContainedAutoTypeLoc())
  if (TL.isConstrained())
    if (AttachTypeConstraint(TL, Param, D.getEllipsisLoc()))
      Invalid = true;

if (Invalid)
  Param->setInvalidDecl();

if (Param->isParameterPack())
  if (auto *LSI = getEnclosingLambda())
    LSI->LocalPacks.push_back(Param);

if (ParamName) {
  maybeDiagnoseTemplateParameterShadow(*this, S, D.getIdentifierLoc(),
                                       ParamName);

  // Add the template parameter into the current scope.
  S->AddDecl(Param);
  IdResolver.AddDecl(Param);
}

// C++0x [temp.param]p9:
//   A default template-argument may be specified for any kind of
//   template-parameter that is not a template parameter pack.
if (Default && IsParameterPack) {
  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
  Default = nullptr;
}

// Check the well-formedness of the default template argument, if provided.
if (Default) {
  // Check for unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
    return Param;

  TemplateArgument Converted;
  ExprResult DefaultRes =
      CheckTemplateArgument(Param, Param->getType(), Default, Converted);
  if (DefaultRes.isInvalid()) {
    Param->setInvalidDecl();
    return Param;
  }
  Default = DefaultRes.get();

  Param->setDefaultArgument(Default);
}

return Param;
1602}

1604/// ActOnTemplateTemplateParameter - Called when a C++ template template
1605/// parameter (e.g. T in template <template \<typename> class T> class array)
1606/// has been parsed. S is the current scope.
1607NamedDecl *Sema::ActOnTemplateTemplateParameter(Scope* S,
                                         SourceLocation TmpLoc,
                                         TemplateParameterList *Params,
                                         SourceLocation EllipsisLoc,
                                         IdentifierInfo *Name,
                                         SourceLocation NameLoc,
                                         unsigned Depth,
                                         unsigned Position,
                                         SourceLocation EqualLoc,
                                         ParsedTemplateArgument Default) {
assert(S->isTemplateParamScope() &&((void)0)
       "Template template parameter not in template parameter scope!")((void)0);

// Construct the parameter object.
bool IsParameterPack = EllipsisLoc.isValid();
TemplateTemplateParmDecl *Param =
  TemplateTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
                                   NameLoc.isInvalid()? TmpLoc : NameLoc,
                                   Depth, Position, IsParameterPack,
                                   Name, Params);
Param->setAccess(AS_public);

if (Param->isParameterPack())
  if (auto *LSI = getEnclosingLambda())
    LSI->LocalPacks.push_back(Param);

// If the template template parameter has a name, then link the identifier
// into the scope and lookup mechanisms.
if (Name) {
  maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);

  S->AddDecl(Param);
  IdResolver.AddDecl(Param);
}

if (Params->size() == 0) {
  Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
  << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
  Param->setInvalidDecl();
}

// C++0x [temp.param]p9:
//   A default template-argument may be specified for any kind of
//   template-parameter that is not a template parameter pack.
if (IsParameterPack && !Default.isInvalid()) {
  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
  Default = ParsedTemplateArgument();
}

if (!Default.isInvalid()) {
  // Check only that we have a template template argument. We don't want to
  // try to check well-formedness now, because our template template parameter
  // might have dependent types in its template parameters, which we wouldn't
  // be able to match now.
  //
  // If none of the template template parameter's template arguments mention
  // other template parameters, we could actually perform more checking here.
  // However, it isn't worth doing.
  TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
  if (DefaultArg.getArgument().getAsTemplate().isNull()) {
    Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
      << DefaultArg.getSourceRange();
    return Param;
  }

  // Check for unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
                                      DefaultArg.getArgument().getAsTemplate(),
                                      UPPC_DefaultArgument))
    return Param;

  Param->setDefaultArgument(Context, DefaultArg);
}

return Param;
1682}

1684/// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
1685/// constrained by RequiresClause, that contains the template parameters in
1686/// Params.
1687TemplateParameterList *
1688Sema::ActOnTemplateParameterList(unsigned Depth,
                               SourceLocation ExportLoc,
                               SourceLocation TemplateLoc,
                               SourceLocation LAngleLoc,
                               ArrayRef<NamedDecl *> Params,
                               SourceLocation RAngleLoc,
                               Expr *RequiresClause) {
if (ExportLoc.isValid())
  Diag(ExportLoc, diag::warn_template_export_unsupported);

for (NamedDecl *P : Params)
  warnOnReservedIdentifier(P);

return TemplateParameterList::Create(
    Context, TemplateLoc, LAngleLoc,
    llvm::makeArrayRef(Params.data(), Params.size()),
    RAngleLoc, RequiresClause);
1705}

1707static void SetNestedNameSpecifier(Sema &S, TagDecl *T,
                                 const CXXScopeSpec &SS) {
if (SS.isSet())
  T->setQualifierInfo(SS.getWithLocInContext(S.Context));
1711}

1713DeclResult Sema::CheckClassTemplate(
  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
  CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
  const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
  SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
  TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {
assert(TemplateParams && TemplateParams->size() > 0 &&((void)0)
       "No template parameters")((void)0);
assert(TUK != TUK_Reference && "Can only declare or define class templates")((void)0);
bool Invalid = false;

// Check that we can declare a template here.
if (CheckTemplateDeclScope(S, TemplateParams))
  return true;

TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum && "can't build template of enumerated type")((void)0);

// There is no such thing as an unnamed class template.
if (!Name) {
  Diag(KWLoc, diag::err_template_unnamed_class);
  return true;
}

// Find any previous declaration with this name. For a friend with no
// scope explicitly specified, we only look for tag declarations (per
// C++11 [basic.lookup.elab]p2).
DeclContext *SemanticContext;
LookupResult Previous(*this, Name, NameLoc,
                      (SS.isEmpty() && TUK == TUK_Friend)
                        ? LookupTagName : LookupOrdinaryName,
                      forRedeclarationInCurContext());
if (SS.isNotEmpty() && !SS.isInvalid()) {
  SemanticContext = computeDeclContext(SS, true);
  if (!SemanticContext) {
    // FIXME: Horrible, horrible hack! We can't currently represent this
    // in the AST, and historically we have just ignored such friend
    // class templates, so don't complain here.
    Diag(NameLoc, TUK == TUK_Friend
                      ? diag::warn_template_qualified_friend_ignored
                      : diag::err_template_qualified_declarator_no_match)
        << SS.getScopeRep() << SS.getRange();
    return TUK != TUK_Friend;
  }

  if (RequireCompleteDeclContext(SS, SemanticContext))
    return true;

  // If we're adding a template to a dependent context, we may need to
  // rebuilding some of the types used within the template parameter list,
  // now that we know what the current instantiation is.
  if (SemanticContext->isDependentContext()) {
    ContextRAII SavedContext(*this, SemanticContext);
    if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
      Invalid = true;
  } else if (TUK != TUK_Friend && TUK != TUK_Reference)
    diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc, false);

  LookupQualifiedName(Previous, SemanticContext);
} else {
  SemanticContext = CurContext;

  // C++14 [class.mem]p14:
  //   If T is the name of a class, then each of the following shall have a
  //   name different from T:
  //    -- every member template of class T
  if (TUK != TUK_Friend &&
      DiagnoseClassNameShadow(SemanticContext,
                              DeclarationNameInfo(Name, NameLoc)))
    return true;

  LookupName(Previous, S);
}

if (Previous.isAmbiguous())
  return true;

NamedDecl *PrevDecl = nullptr;
if (Previous.begin() != Previous.end())
  PrevDecl = (*Previous.begin())->getUnderlyingDecl();

if (PrevDecl && PrevDecl->isTemplateParameter()) {
  // Maybe we will complain about the shadowed template parameter.
  DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
  // Just pretend that we didn't see the previous declaration.
  PrevDecl = nullptr;
}

// If there is a previous declaration with the same name, check
// whether this is a valid redeclaration.
ClassTemplateDecl *PrevClassTemplate =
    dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);

// We may have found the injected-class-name of a class template,
// class template partial specialization, or class template specialization.
// In these cases, grab the template that is being defined or specialized.
if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
    cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
  PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
  PrevClassTemplate
    = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
  if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
    PrevClassTemplate
      = cast<ClassTemplateSpecializationDecl>(PrevDecl)
          ->getSpecializedTemplate();
  }
}

if (TUK == TUK_Friend) {
  // C++ [namespace.memdef]p3:
  //   [...] When looking for a prior declaration of a class or a function
  //   declared as a friend, and when the name of the friend class or
  //   function is neither a qualified name nor a template-id, scopes outside
  //   the innermost enclosing namespace scope are not considered.
  if (!SS.isSet()) {
    DeclContext *OutermostContext = CurContext;
    while (!OutermostContext->isFileContext())
      OutermostContext = OutermostContext->getLookupParent();

    if (PrevDecl &&
        (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
         OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
      SemanticContext = PrevDecl->getDeclContext();
    } else {
      // Declarations in outer scopes don't matter. However, the outermost
      // context we computed is the semantic context for our new
      // declaration.
      PrevDecl = PrevClassTemplate = nullptr;
      SemanticContext = OutermostContext;

      // Check that the chosen semantic context doesn't already contain a
      // declaration of this name as a non-tag type.
      Previous.clear(LookupOrdinaryName);
      DeclContext *LookupContext = SemanticContext;
      while (LookupContext->isTransparentContext())
        LookupContext = LookupContext->getLookupParent();
      LookupQualifiedName(Previous, LookupContext);

      if (Previous.isAmbiguous())
        return true;

      if (Previous.begin() != Previous.end())
        PrevDecl = (*Previous.begin())->getUnderlyingDecl();
    }
  }
} else if (PrevDecl &&
           !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
                          S, SS.isValid()))
  PrevDecl = PrevClassTemplate = nullptr;

if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
        PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
  if (SS.isEmpty() &&
      !(PrevClassTemplate &&
        PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
            SemanticContext->getRedeclContext()))) {
    Diag(KWLoc, diag::err_using_decl_conflict_reverse);
    Diag(Shadow->getTargetDecl()->getLocation(),
         diag::note_using_decl_target);
    Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
    // Recover by ignoring the old declaration.
    PrevDecl = PrevClassTemplate = nullptr;
  }
}

if (PrevClassTemplate) {
  // Ensure that the template parameter lists are compatible. Skip this check
  // for a friend in a dependent context: the template parameter list itself
  // could be dependent.
  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
      !TemplateParameterListsAreEqual(TemplateParams,
                                 PrevClassTemplate->getTemplateParameters(),
                                      /*Complain=*/true,
                                      TPL_TemplateMatch))
    return true;

  // C++ [temp.class]p4:
  //   In a redeclaration, partial specialization, explicit
  //   specialization or explicit instantiation of a class template,
  //   the class-key shall agree in kind with the original class
  //   template declaration (7.1.5.3).
  RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
  if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
                                    TUK == TUK_Definition,  KWLoc, Name)) {
    Diag(KWLoc, diag::err_use_with_wrong_tag)
      << Name
      << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
    Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
    Kind = PrevRecordDecl->getTagKind();
  }

  // Check for redefinition of this class template.
  if (TUK == TUK_Definition) {
    if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
      // If we have a prior definition that is not visible, treat this as
      // simply making that previous definition visible.
      NamedDecl *Hidden = nullptr;
      if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
        SkipBody->ShouldSkip = true;
        SkipBody->Previous = Def;
        auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
        assert(Tmpl && "original definition of a class template is not a "((void)0)
                       "class template?")((void)0);
        makeMergedDefinitionVisible(Hidden);
        makeMergedDefinitionVisible(Tmpl);
      } else {
        Diag(NameLoc, diag::err_redefinition) << Name;
        Diag(Def->getLocation(), diag::note_previous_definition);
        // FIXME: Would it make sense to try to "forget" the previous
        // definition, as part of error recovery?
        return true;
      }
    }
  }
} else if (PrevDecl) {
  // C++ [temp]p5:
  //   A class template shall not have the same name as any other
  //   template, class, function, object, enumeration, enumerator,
  //   namespace, or type in the same scope (3.3), except as specified
  //   in (14.5.4).
  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
  return true;
}

// Check the template parameter list of this declaration, possibly
// merging in the template parameter list from the previous class
// template declaration. Skip this check for a friend in a dependent
// context, because the template parameter list might be dependent.
if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
    CheckTemplateParameterList(
        TemplateParams,
        PrevClassTemplate
            ? PrevClassTemplate->getMostRecentDecl()->getTemplateParameters()
            : nullptr,
        (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
         SemanticContext->isDependentContext())
            ? TPC_ClassTemplateMember
            : TUK == TUK_Friend ? TPC_FriendClassTemplate : TPC_ClassTemplate,
        SkipBody))
  Invalid = true;

if (SS.isSet()) {
  // If the name of the template was qualified, we must be defining the
  // template out-of-line.
  if (!SS.isInvalid() && !Invalid && !PrevClassTemplate) {
    Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
                                    : diag::err_member_decl_does_not_match)
      << Name << SemanticContext << /*IsDefinition*/true << SS.getRange();
    Invalid = true;
  }
}

// If this is a templated friend in a dependent context we should not put it
// on the redecl chain. In some cases, the templated friend can be the most
// recent declaration tricking the template instantiator to make substitutions
// there.
// FIXME: Figure out how to combine with shouldLinkDependentDeclWithPrevious
bool ShouldAddRedecl
  = !(TUK == TUK_Friend && CurContext->isDependentContext());

CXXRecordDecl *NewClass =
  CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
                        PrevClassTemplate && ShouldAddRedecl ?
                          PrevClassTemplate->getTemplatedDecl() : nullptr,
                        /*DelayTypeCreation=*/true);
SetNestedNameSpecifier(*this, NewClass, SS);
if (NumOuterTemplateParamLists > 0)
  NewClass->setTemplateParameterListsInfo(
      Context, llvm::makeArrayRef(OuterTemplateParamLists,
                                  NumOuterTemplateParamLists));

// Add alignment attributes if necessary; these attributes are checked when
// the ASTContext lays out the structure.
if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) {
  AddAlignmentAttributesForRecord(NewClass);
  AddMsStructLayoutForRecord(NewClass);
}

ClassTemplateDecl *NewTemplate
  = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
                              DeclarationName(Name), TemplateParams,
                              NewClass);

if (ShouldAddRedecl)
  NewTemplate->setPreviousDecl(PrevClassTemplate);

NewClass->setDescribedClassTemplate(NewTemplate);

if (ModulePrivateLoc.isValid())
  NewTemplate->setModulePrivate();

// Build the type for the class template declaration now.
QualType T = NewTemplate->getInjectedClassNameSpecialization();
T = Context.getInjectedClassNameType(NewClass, T);
assert(T->isDependentType() && "Class template type is not dependent?")((void)0);
(void)T;

// If we are providing an explicit specialization of a member that is a
// class template, make a note of that.
if (PrevClassTemplate &&
    PrevClassTemplate->getInstantiatedFromMemberTemplate())
  PrevClassTemplate->setMemberSpecialization();

// Set the access specifier.
if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord())
  SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);

// Set the lexical context of these templates
NewClass->setLexicalDeclContext(CurContext);
NewTemplate->setLexicalDeclContext(CurContext);

if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip))
  NewClass->startDefinition();

ProcessDeclAttributeList(S, NewClass, Attr);

if (PrevClassTemplate)
  mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());

AddPushedVisibilityAttribute(NewClass);
inferGslOwnerPointerAttribute(NewClass);

if (TUK != TUK_Friend) {
  // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
  Scope *Outer = S;
  while ((Outer->getFlags() & Scope::TemplateParamScope) != 0)
    Outer = Outer->getParent();
  PushOnScopeChains(NewTemplate, Outer);
} else {
  if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
    NewTemplate->setAccess(PrevClassTemplate->getAccess());
    NewClass->setAccess(PrevClassTemplate->getAccess());
  }

  NewTemplate->setObjectOfFriendDecl();

  // Friend templates are visible in fairly strange ways.
  if (!CurContext->isDependentContext()) {
    DeclContext *DC = SemanticContext->getRedeclContext();
    DC->makeDeclVisibleInContext(NewTemplate);
    if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
      PushOnScopeChains(NewTemplate, EnclosingScope,
                        /* AddToContext = */ false);
  }

  FriendDecl *Friend = FriendDecl::Create(
      Context, CurContext, NewClass->getLocation(), NewTemplate, FriendLoc);
  Friend->setAccess(AS_public);
  CurContext->addDecl(Friend);
}

if (PrevClassTemplate)
  CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);

if (Invalid) {
  NewTemplate->setInvalidDecl();
  NewClass->setInvalidDecl();
}

ActOnDocumentableDecl(NewTemplate);

if (SkipBody && SkipBody->ShouldSkip)
  return SkipBody->Previous;

return NewTemplate;
2080}

2082namespace {
2083/// Tree transform to "extract" a transformed type from a class template's
2084/// constructor to a deduction guide.
2085class ExtractTypeForDeductionGuide
: public TreeTransform<ExtractTypeForDeductionGuide> {
llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs;

2089public:
typedef TreeTransform<ExtractTypeForDeductionGuide> Base;
ExtractTypeForDeductionGuide(
    Sema &SemaRef,
    llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs)
    : Base(SemaRef), MaterializedTypedefs(MaterializedTypedefs) {}

TypeSourceInfo *transform(TypeSourceInfo *TSI) { return TransformType(TSI); }

QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
  ASTContext &Context = SemaRef.getASTContext();
  TypedefNameDecl *OrigDecl = TL.getTypedefNameDecl();
  TypedefNameDecl *Decl = OrigDecl;
  // Transform the underlying type of the typedef and clone the Decl only if
  // the typedef has a dependent context.
  if (OrigDecl->getDeclContext()->isDependentContext()) {
    TypeLocBuilder InnerTLB;
    QualType Transformed =
        TransformType(InnerTLB, OrigDecl->getTypeSourceInfo()->getTypeLoc());
    TypeSourceInfo *TSI = InnerTLB.getTypeSourceInfo(Context, Transformed);
    if (isa<TypeAliasDecl>(OrigDecl))
      Decl = TypeAliasDecl::Create(
          Context, Context.getTranslationUnitDecl(), OrigDecl->getBeginLoc(),
          OrigDecl->getLocation(), OrigDecl->getIdentifier(), TSI);
    else {
      assert(isa<TypedefDecl>(OrigDecl) && "Not a Type alias or typedef")((void)0);
      Decl = TypedefDecl::Create(
          Context, Context.getTranslationUnitDecl(), OrigDecl->getBeginLoc(),
          OrigDecl->getLocation(), OrigDecl->getIdentifier(), TSI);
    }
    MaterializedTypedefs.push_back(Decl);
  }

  QualType TDTy = Context.getTypedefType(Decl);
  TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(TDTy);
  TypedefTL.setNameLoc(TL.getNameLoc());

  return TDTy;
}
2128};

2130/// Transform to convert portions of a constructor declaration into the
2131/// corresponding deduction guide, per C++1z [over.match.class.deduct]p1.
2132struct ConvertConstructorToDeductionGuideTransform {
ConvertConstructorToDeductionGuideTransform(Sema &S,
                                            ClassTemplateDecl *Template)
    : SemaRef(S), Template(Template) {}

Sema &SemaRef;
ClassTemplateDecl *Template;

DeclContext *DC = Template->getDeclContext();
CXXRecordDecl *Primary = Template->getTemplatedDecl();
DeclarationName DeductionGuideName =
    SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(Template);

QualType DeducedType = SemaRef.Context.getTypeDeclType(Primary);

// Index adjustment to apply to convert depth-1 template parameters into
// depth-0 template parameters.
unsigned Depth1IndexAdjustment = Template->getTemplateParameters()->size();

/// Transform a constructor declaration into a deduction guide.
NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
                                CXXConstructorDecl *CD) {
  SmallVector<TemplateArgument, 16> SubstArgs;

  LocalInstantiationScope Scope(SemaRef);

  // C++ [over.match.class.deduct]p1:
  // -- For each constructor of the class template designated by the
  //    template-name, a function template with the following properties:

  //    -- The template parameters are the template parameters of the class
  //       template followed by the template parameters (including default
  //       template arguments) of the constructor, if any.
  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
  if (FTD) {
    TemplateParameterList *InnerParams = FTD->getTemplateParameters();
    SmallVector<NamedDecl *, 16> AllParams;
    AllParams.reserve(TemplateParams->size() + InnerParams->size());
    AllParams.insert(AllParams.begin(),
                     TemplateParams->begin(), TemplateParams->end());
    SubstArgs.reserve(InnerParams->size());

    // Later template parameters could refer to earlier ones, so build up
    // a list of substituted template arguments as we go.
    for (NamedDecl *Param : *InnerParams) {
      MultiLevelTemplateArgumentList Args;
      Args.setKind(TemplateSubstitutionKind::Rewrite);
      Args.addOuterTemplateArguments(SubstArgs);
      Args.addOuterRetainedLevel();
      NamedDecl *NewParam = transformTemplateParameter(Param, Args);
      if (!NewParam)
        return nullptr;
      AllParams.push_back(NewParam);
      SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument(
          SemaRef.Context.getInjectedTemplateArg(NewParam)));
    }
    TemplateParams = TemplateParameterList::Create(
        SemaRef.Context, InnerParams->getTemplateLoc(),
        InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
        /*FIXME: RequiresClause*/ nullptr);
  }

  // If we built a new template-parameter-list, track that we need to
  // substitute references to the old parameters into references to the
  // new ones.
  MultiLevelTemplateArgumentList Args;
  Args.setKind(TemplateSubstitutionKind::Rewrite);
  if (FTD) {
    Args.addOuterTemplateArguments(SubstArgs);
    Args.addOuterRetainedLevel();
  }

  FunctionProtoTypeLoc FPTL = CD->getTypeSourceInfo()->getTypeLoc()
                                 .getAsAdjusted<FunctionProtoTypeLoc>();
  assert(FPTL && "no prototype for constructor declaration")((void)0);

  // Transform the type of the function, adjusting the return type and
  // replacing references to the old parameters with references to the
  // new ones.
  TypeLocBuilder TLB;
  SmallVector<ParmVarDecl*, 8> Params;
  SmallVector<TypedefNameDecl *, 4> MaterializedTypedefs;
  QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args,
                                                MaterializedTypedefs);
  if (NewType.isNull())
    return nullptr;
  TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);

  return buildDeductionGuide(TemplateParams, CD, CD->getExplicitSpecifier(),
                             NewTInfo, CD->getBeginLoc(), CD->getLocation(),
                             CD->getEndLoc(), MaterializedTypedefs);
}

/// Build a deduction guide with the specified parameter types.
NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
  SourceLocation Loc = Template->getLocation();

  // Build the requested type.
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.HasTrailingReturn = true;
  QualType Result = SemaRef.BuildFunctionType(DeducedType, ParamTypes, Loc,
                                              DeductionGuideName, EPI);
  TypeSourceInfo *TSI = SemaRef.Context.getTrivialTypeSourceInfo(Result, Loc);

  FunctionProtoTypeLoc FPTL =
      TSI->getTypeLoc().castAs<FunctionProtoTypeLoc>();

  // Build the parameters, needed during deduction / substitution.
  SmallVector<ParmVarDecl*, 4> Params;
  for (auto T : ParamTypes) {
    ParmVarDecl *NewParam = ParmVarDecl::Create(
        SemaRef.Context, DC, Loc, Loc, nullptr, T,
        SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
    NewParam->setScopeInfo(0, Params.size());
    FPTL.setParam(Params.size(), NewParam);
    Params.push_back(NewParam);
  }

  return buildDeductionGuide(Template->getTemplateParameters(), nullptr,
                             ExplicitSpecifier(), TSI, Loc, Loc, Loc);
}

2254private:
/// Transform a constructor template parameter into a deduction guide template
/// parameter, rebuilding any internal references to earlier parameters and
/// renumbering as we go.
NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
                                      MultiLevelTemplateArgumentList &Args) {
  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
    // TemplateTypeParmDecl's index cannot be changed after creation, so
    // substitute it directly.
    auto *NewTTP = TemplateTypeParmDecl::Create(
        SemaRef.Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
        /*Depth*/ 0, Depth1IndexAdjustment + TTP->getIndex(),
        TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
        TTP->isParameterPack(), TTP->hasTypeConstraint(),
        TTP->isExpandedParameterPack() ?
        llvm::Optional<unsigned>(TTP->getNumExpansionParameters()) : None);
    if (const auto *TC = TTP->getTypeConstraint()) {
      TemplateArgumentListInfo TransformedArgs;
      const auto *ArgsAsWritten = TC->getTemplateArgsAsWritten();
      if (!ArgsAsWritten ||
          SemaRef.Subst(ArgsAsWritten->getTemplateArgs(),
                        ArgsAsWritten->NumTemplateArgs, TransformedArgs,
                        Args))
        SemaRef.AttachTypeConstraint(
            TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
            TC->getNamedConcept(), ArgsAsWritten ? &TransformedArgs : nullptr,
            NewTTP,
            NewTTP->isParameterPack()
               ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
                   ->getEllipsisLoc()
               : SourceLocation());
    }
    if (TTP->hasDefaultArgument()) {
      TypeSourceInfo *InstantiatedDefaultArg =
          SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
                            TTP->getDefaultArgumentLoc(), TTP->getDeclName());
      if (InstantiatedDefaultArg)
        NewTTP->setDefaultArgument(InstantiatedDefaultArg);
    }
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
                                                         NewTTP);
    return NewTTP;
  }

  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
    return transformTemplateParameterImpl(TTP, Args);

  return transformTemplateParameterImpl(
      cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
}
template<typename TemplateParmDecl>
TemplateParmDecl *
transformTemplateParameterImpl(TemplateParmDecl *OldParam,
                               MultiLevelTemplateArgumentList &Args) {
  // Ask the template instantiator to do the heavy lifting for us, then adjust
  // the index of the parameter once it's done.
  auto *NewParam =
      cast<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
  assert(NewParam->getDepth() == 0 && "unexpected template param depth")((void)0);
  NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
  return NewParam;
}

QualType transformFunctionProtoType(
    TypeLocBuilder &TLB, FunctionProtoTypeLoc TL,
    SmallVectorImpl<ParmVarDecl *> &Params,
    MultiLevelTemplateArgumentList &Args,
    SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs) {
  SmallVector<QualType, 4> ParamTypes;
  const FunctionProtoType *T = TL.getTypePtr();

  //    -- The types of the function parameters are those of the constructor.
  for (auto *OldParam : TL.getParams()) {
    ParmVarDecl *NewParam =
        transformFunctionTypeParam(OldParam, Args, MaterializedTypedefs);
    if (!NewParam)
      return QualType();
    ParamTypes.push_back(NewParam->getType());
    Params.push_back(NewParam);
  }

  //    -- The return type is the class template specialization designated by
  //       the template-name and template arguments corresponding to the
  //       template parameters obtained from the class template.
  //
  // We use the injected-class-name type of the primary template instead.
  // This has the convenient property that it is different from any type that
  // the user can write in a deduction-guide (because they cannot enter the
  // context of the template), so implicit deduction guides can never collide
  // with explicit ones.
  QualType ReturnType = DeducedType;
  TLB.pushTypeSpec(ReturnType).setNameLoc(Primary->getLocation());

  // Resolving a wording defect, we also inherit the variadicness of the
  // constructor.
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = T->isVariadic();
  EPI.HasTrailingReturn = true;

  QualType Result = SemaRef.BuildFunctionType(
      ReturnType, ParamTypes, TL.getBeginLoc(), DeductionGuideName, EPI);
  if (Result.isNull())
    return QualType();

  FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
  NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
  NewTL.setLParenLoc(TL.getLParenLoc());
  NewTL.setRParenLoc(TL.getRParenLoc());
  NewTL.setExceptionSpecRange(SourceRange());
  NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
  for (unsigned I = 0, E = NewTL.getNumParams(); I != E; ++I)
    NewTL.setParam(I, Params[I]);

  return Result;
}

ParmVarDecl *transformFunctionTypeParam(
    ParmVarDecl *OldParam, MultiLevelTemplateArgumentList &Args,
    llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs) {
  TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
  TypeSourceInfo *NewDI;
  if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
    // Expand out the one and only element in each inner pack.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0);
    NewDI =
        SemaRef.SubstType(PackTL.getPatternLoc(), Args,
                          OldParam->getLocation(), OldParam->getDeclName());
    if (!NewDI) return nullptr;
    NewDI =
        SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
                                   PackTL.getTypePtr()->getNumExpansions());
  } else
    NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
                              OldParam->getDeclName());
  if (!NewDI)
    return nullptr;

  // Extract the type. This (for instance) replaces references to typedef
  // members of the current instantiations with the definitions of those
  // typedefs, avoiding triggering instantiation of the deduced type during
  // deduction.
  NewDI = ExtractTypeForDeductionGuide(SemaRef, MaterializedTypedefs)
              .transform(NewDI);

  // Resolving a wording defect, we also inherit default arguments from the
  // constructor.
  ExprResult NewDefArg;
  if (OldParam->hasDefaultArg()) {
    // We don't care what the value is (we won't use it); just create a
    // placeholder to indicate there is a default argument.
    QualType ParamTy = NewDI->getType();
    NewDefArg = new (SemaRef.Context)
        OpaqueValueExpr(OldParam->getDefaultArg()->getBeginLoc(),
                        ParamTy.getNonLValueExprType(SemaRef.Context),
                        ParamTy->isLValueReferenceType()   ? VK_LValue
                        : ParamTy->isRValueReferenceType() ? VK_XValue
                                                           : VK_PRValue);
  }

  ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
                                              OldParam->getInnerLocStart(),
                                              OldParam->getLocation(),
                                              OldParam->getIdentifier(),
                                              NewDI->getType(),
                                              NewDI,
                                              OldParam->getStorageClass(),
                                              NewDefArg.get());
  NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
                         OldParam->getFunctionScopeIndex());
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldParam, NewParam);
  return NewParam;
}

FunctionTemplateDecl *buildDeductionGuide(
    TemplateParameterList *TemplateParams, CXXConstructorDecl *Ctor,
    ExplicitSpecifier ES, TypeSourceInfo *TInfo, SourceLocation LocStart,
    SourceLocation Loc, SourceLocation LocEnd,
    llvm::ArrayRef<TypedefNameDecl *> MaterializedTypedefs = {}) {
  DeclarationNameInfo Name(DeductionGuideName, Loc);
  ArrayRef<ParmVarDecl *> Params =
      TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();

  // Build the implicit deduction guide template.
  auto *Guide =
      CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, ES, Name,
                                    TInfo->getType(), TInfo, LocEnd, Ctor);
  Guide->setImplicit();
  Guide->setParams(Params);

  for (auto *Param : Params)
    Param->setDeclContext(Guide);
  for (auto *TD : MaterializedTypedefs)
    TD->setDeclContext(Guide);

  auto *GuideTemplate = FunctionTemplateDecl::Create(
      SemaRef.Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
  GuideTemplate->setImplicit();
  Guide->setDescribedFunctionTemplate(GuideTemplate);

  if (isa<CXXRecordDecl>(DC)) {
    Guide->setAccess(AS_public);
    GuideTemplate->setAccess(AS_public);
  }

  DC->addDecl(GuideTemplate);
  return GuideTemplate;
}
2461};
2462}

2464void Sema::DeclareImplicitDeductionGuides(TemplateDecl *Template,
                                        SourceLocation Loc) {
if (CXXRecordDecl *DefRecord =
        cast<CXXRecordDecl>(Template->getTemplatedDecl())->getDefinition()) {
  TemplateDecl *DescribedTemplate = DefRecord->getDescribedClassTemplate();
  Template = DescribedTemplate ? DescribedTemplate : Template;
}

DeclContext *DC = Template->getDeclContext();
if (DC->isDependentContext())
  return;

ConvertConstructorToDeductionGuideTransform Transform(
    *this, cast<ClassTemplateDecl>(Template));
if (!isCompleteType(Loc, Transform.DeducedType))
  return;

// Check whether we've already declared deduction guides for this template.
// FIXME: Consider storing a flag on the template to indicate this.
auto Existing = DC->lookup(Transform.DeductionGuideName);
for (auto *D : Existing)
  if (D->isImplicit())
    return;

// In case we were expanding a pack when we attempted to declare deduction
// guides, turn off pack expansion for everything we're about to do.
ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
// Create a template instantiation record to track the "instantiation" of
// constructors into deduction guides.
// FIXME: Add a kind for this to give more meaningful diagnostics. But can
// this substitution process actually fail?
InstantiatingTemplate BuildingDeductionGuides(*this, Loc, Template);
if (BuildingDeductionGuides.isInvalid())
  return;

// Convert declared constructors into deduction guide templates.
// FIXME: Skip constructors for which deduction must necessarily fail (those
// for which some class template parameter without a default argument never
// appears in a deduced context).
bool AddedAny = false;
for (NamedDecl *D : LookupConstructors(Transform.Primary)) {
  D = D->getUnderlyingDecl();
  if (D->isInvalidDecl() || D->isImplicit())
    continue;
  D = cast<NamedDecl>(D->getCanonicalDecl());

  auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
  auto *CD =
      dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
  // Class-scope explicit specializations (MS extension) do not result in
  // deduction guides.
  if (!CD || (!FTD && CD->isFunctionTemplateSpecialization()))
    continue;

  // Cannot make a deduction guide when unparsed arguments are present.
  if (std::any_of(CD->param_begin(), CD->param_end(), [](ParmVarDecl *P) {
        return !P || P->hasUnparsedDefaultArg();
      }))
    continue;

  Transform.transformConstructor(FTD, CD);
  AddedAny = true;
}

// C++17 [over.match.class.deduct]
//    --  If C is not defined or does not declare any constructors, an
//    additional function template derived as above from a hypothetical
//    constructor C().
if (!AddedAny)
  Transform.buildSimpleDeductionGuide(None);

//    -- An additional function template derived as above from a hypothetical
//    constructor C(C), called the copy deduction candidate.
cast<CXXDeductionGuideDecl>(
    cast<FunctionTemplateDecl>(
        Transform.buildSimpleDeductionGuide(Transform.DeducedType))
        ->getTemplatedDecl())
    ->setIsCopyDeductionCandidate();
2542}

2544/// Diagnose the presence of a default template argument on a
2545/// template parameter, which is ill-formed in certain contexts.
2546///
2547/// \returns true if the default template argument should be dropped.
2548static bool DiagnoseDefaultTemplateArgument(Sema &S,
                                          Sema::TemplateParamListContext TPC,
                                          SourceLocation ParamLoc,
                                          SourceRange DefArgRange) {
switch (TPC) {
case Sema::TPC_ClassTemplate:
case Sema::TPC_VarTemplate:
case Sema::TPC_TypeAliasTemplate:
  return false;

case Sema::TPC_FunctionTemplate:
case Sema::TPC_FriendFunctionTemplateDefinition:
  // C++ [temp.param]p9:
  //   A default template-argument shall not be specified in a
  //   function template declaration or a function template
  //   definition [...]
  //   If a friend function template declaration specifies a default
  //   template-argument, that declaration shall be a definition and shall be
  //   the only declaration of the function template in the translation unit.
  // (C++98/03 doesn't have this wording; see DR226).
  S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
       diag::warn_cxx98_compat_template_parameter_default_in_function_template
         : diag::ext_template_parameter_default_in_function_template)
    << DefArgRange;
  return false;

case Sema::TPC_ClassTemplateMember:
  // C++0x [temp.param]p9:
  //   A default template-argument shall not be specified in the
  //   template-parameter-lists of the definition of a member of a
  //   class template that appears outside of the member's class.
  S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
    << DefArgRange;
  return true;

case Sema::TPC_FriendClassTemplate:
case Sema::TPC_FriendFunctionTemplate:
  // C++ [temp.param]p9:
  //   A default template-argument shall not be specified in a
  //   friend template declaration.
  S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
    << DefArgRange;
  return true;

  // FIXME: C++0x [temp.param]p9 allows default template-arguments
  // for friend function templates if there is only a single
  // declaration (and it is a definition). Strange!
}

llvm_unreachable("Invalid TemplateParamListContext!")__builtin_unreachable();
2598}

2600/// Check for unexpanded parameter packs within the template parameters
2601/// of a template template parameter, recursively.
2602static bool DiagnoseUnexpandedParameterPacks(Sema &S,
                                           TemplateTemplateParmDecl *TTP) {
// A template template parameter which is a parameter pack is also a pack
// expansion.
if (TTP->isParameterPack())
  return false;

TemplateParameterList *Params = TTP->getTemplateParameters();
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  NamedDecl *P = Params->getParam(I);
  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
    if (!TTP->isParameterPack())
      if (const TypeConstraint *TC = TTP->getTypeConstraint())
        if (TC->hasExplicitTemplateArgs())
          for (auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
            if (S.DiagnoseUnexpandedParameterPack(ArgLoc,
                                                  Sema::UPPC_TypeConstraint))
              return true;
    continue;
  }

  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
    if (!NTTP->isParameterPack() &&
        S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
                                          NTTP->getTypeSourceInfo(),
                                    Sema::UPPC_NonTypeTemplateParameterType))
      return true;

    continue;
  }

  if (TemplateTemplateParmDecl *InnerTTP
                                      = dyn_cast<TemplateTemplateParmDecl>(P))
    if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
      return true;
}

return false;
2640}

2642/// Checks the validity of a template parameter list, possibly
2643/// considering the template parameter list from a previous
2644/// declaration.
2645///
2646/// If an "old" template parameter list is provided, it must be
2647/// equivalent (per TemplateParameterListsAreEqual) to the "new"
2648/// template parameter list.
2649///
2650/// \param NewParams Template parameter list for a new template
2651/// declaration. This template parameter list will be updated with any
2652/// default arguments that are carried through from the previous
2653/// template parameter list.
2654///
2655/// \param OldParams If provided, template parameter list from a
2656/// previous declaration of the same template. Default template
2657/// arguments will be merged from the old template parameter list to
2658/// the new template parameter list.
2659///
2660/// \param TPC Describes the context in which we are checking the given
2661/// template parameter list.
2662///
2663/// \param SkipBody If we might have already made a prior merged definition
2664/// of this template visible, the corresponding body-skipping information.
2665/// Default argument redefinition is not an error when skipping such a body,
2666/// because (under the ODR) we can assume the default arguments are the same
2667/// as the prior merged definition.
2668///
2669/// \returns true if an error occurred, false otherwise.
2670bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
                                    TemplateParameterList *OldParams,
                                    TemplateParamListContext TPC,
                                    SkipBodyInfo *SkipBody) {
bool Invalid = false;

// C++ [temp.param]p10:
//   The set of default template-arguments available for use with a
//   template declaration or definition is obtained by merging the
//   default arguments from the definition (if in scope) and all
//   declarations in scope in the same way default function
//   arguments are (8.3.6).
bool SawDefaultArgument = false;
SourceLocation PreviousDefaultArgLoc;

// Dummy initialization to avoid warnings.
TemplateParameterList::iterator OldParam = NewParams->end();
if (OldParams)
  OldParam = OldParams->begin();

bool RemoveDefaultArguments = false;
for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                  NewParamEnd = NewParams->end();
     NewParam != NewParamEnd; ++NewParam) {
  // Variables used to diagnose redundant default arguments
  bool RedundantDefaultArg = false;
  SourceLocation OldDefaultLoc;
  SourceLocation NewDefaultLoc;

  // Variable used to diagnose missing default arguments
  bool MissingDefaultArg = false;

  // Variable used to diagnose non-final parameter packs
  bool SawParameterPack = false;

  if (TemplateTypeParmDecl *NewTypeParm
        = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
    // Check the presence of a default argument here.
    if (NewTypeParm->hasDefaultArgument() &&
        DiagnoseDefaultTemplateArgument(*this, TPC,
                                        NewTypeParm->getLocation(),
             NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
                                                     .getSourceRange()))
      NewTypeParm->removeDefaultArgument();

    // Merge default arguments for template type parameters.
    TemplateTypeParmDecl *OldTypeParm
        = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
    if (NewTypeParm->isParameterPack()) {
      assert(!NewTypeParm->hasDefaultArgument() &&((void)0)
             "Parameter packs can't have a default argument!")((void)0);
      SawParameterPack = true;
    } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
               NewTypeParm->hasDefaultArgument() &&
               (!SkipBody || !SkipBody->ShouldSkip)) {
      OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
      NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
      PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
    } else if (NewTypeParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  } else if (NonTypeTemplateParmDecl *NewNonTypeParm
             = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
    // Check for unexpanded parameter packs.
    if (!NewNonTypeParm->isParameterPack() &&
        DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
                                        NewNonTypeParm->getTypeSourceInfo(),
                                        UPPC_NonTypeTemplateParameterType)) {
      Invalid = true;
      continue;
    }

    // Check the presence of a default argument here.
    if (NewNonTypeParm->hasDefaultArgument() &&
        DiagnoseDefaultTemplateArgument(*this, TPC,
                                        NewNonTypeParm->getLocation(),
                  NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
      NewNonTypeParm->removeDefaultArgument();
    }

    // Merge default arguments for non-type template parameters
    NonTypeTemplateParmDecl *OldNonTypeParm
      = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
    if (NewNonTypeParm->isParameterPack()) {
      assert(!NewNonTypeParm->hasDefaultArgument() &&((void)0)
             "Parameter packs can't have a default argument!")((void)0);
      if (!NewNonTypeParm->isPackExpansion())
        SawParameterPack = true;
    } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
               NewNonTypeParm->hasDefaultArgument() &&
               (!SkipBody || !SkipBody->ShouldSkip)) {
      OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
      NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
      PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
    } else if (NewNonTypeParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  } else {
    TemplateTemplateParmDecl *NewTemplateParm
      = cast<TemplateTemplateParmDecl>(*NewParam);

    // Check for unexpanded parameter packs, recursively.
    if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
      Invalid = true;
      continue;
    }

    // Check the presence of a default argument here.
    if (NewTemplateParm->hasDefaultArgument() &&
        DiagnoseDefaultTemplateArgument(*this, TPC,
                                        NewTemplateParm->getLocation(),
                   NewTemplateParm->getDefaultArgument().getSourceRange()))
      NewTemplateParm->removeDefaultArgument();

    // Merge default arguments for template template parameters
    TemplateTemplateParmDecl *OldTemplateParm
      = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
    if (NewTemplateParm->isParameterPack()) {
      assert(!NewTemplateParm->hasDefaultArgument() &&((void)0)
             "Parameter packs can't have a default argument!")((void)0);
      if (!NewTemplateParm->isPackExpansion())
        SawParameterPack = true;
    } else if (OldTemplateParm &&
               hasVisibleDefaultArgument(OldTemplateParm) &&
               NewTemplateParm->hasDefaultArgument() &&
               (!SkipBody || !SkipBody->ShouldSkip)) {
      OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
      NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
      PreviousDefaultArgLoc
        = OldTemplateParm->getDefaultArgument().getLocation();
    } else if (NewTemplateParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc
        = NewTemplateParm->getDefaultArgument().getLocation();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  }

  // C++11 [temp.param]p11:
  //   If a template parameter of a primary class template or alias template
  //   is a template parameter pack, it shall be the last template parameter.
  if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
      (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
       TPC == TPC_TypeAliasTemplate)) {
    Diag((*NewParam)->getLocation(),
         diag::err_template_param_pack_must_be_last_template_parameter);
    Invalid = true;
  }

  if (RedundantDefaultArg) {
    // C++ [temp.param]p12:
    //   A template-parameter shall not be given default arguments
    //   by two different declarations in the same scope.
    Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
    Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
    Invalid = true;
  } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
    // C++ [temp.param]p11:
    //   If a template-parameter of a class template has a default
    //   template-argument, each subsequent template-parameter shall either
    //   have a default template-argument supplied or be a template parameter
    //   pack.
    Diag((*NewParam)->getLocation(),
         diag::err_template_param_default_arg_missing);
    Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
    Invalid = true;
    RemoveDefaultArguments = true;
  }

  // If we have an old template parameter list that we're merging
  // in, move on to the next parameter.
  if (OldParams)
    ++OldParam;
}

// We were missing some default arguments at the end of the list, so remove
// all of the default arguments.
if (RemoveDefaultArguments) {
  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                    NewParamEnd = NewParams->end();
       NewParam != NewParamEnd; ++NewParam) {
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
      TTP->removeDefaultArgument();
    else if (NonTypeTemplateParmDecl *NTTP
                              = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
      NTTP->removeDefaultArgument();
    else
      cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
  }
}

return Invalid;
2887}

2889namespace {

2891/// A class which looks for a use of a certain level of template
2892/// parameter.
2893struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
typedef RecursiveASTVisitor<DependencyChecker> super;

unsigned Depth;

// Whether we're looking for a use of a template parameter that makes the
// overall construct type-dependent / a dependent type. This is strictly
// best-effort for now; we may fail to match at all for a dependent type
// in some cases if this is set.
bool IgnoreNonTypeDependent;

bool Match;
SourceLocation MatchLoc;

DependencyChecker(unsigned Depth, bool IgnoreNonTypeDependent)
    : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
      Match(false) {}

DependencyChecker(TemplateParameterList *Params, bool IgnoreNonTypeDependent)
    : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(false) {
  NamedDecl *ND = Params->getParam(0);
  if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
    Depth = PD->getDepth();
  } else if (NonTypeTemplateParmDecl *PD =
               dyn_cast<NonTypeTemplateParmDecl>(ND)) {
    Depth = PD->getDepth();
  } else {
    Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
  }
}

bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
  if (ParmDepth >= Depth) {
    Match = true;
    MatchLoc = Loc;
    return true;
  }
  return false;
}

bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
  // Prune out non-type-dependent expressions if requested. This can
  // sometimes result in us failing to find a template parameter reference
  // (if a value-dependent expression creates a dependent type), but this
  // mode is best-effort only.
  if (auto *E = dyn_cast_or_null<Expr>(S))
    if (IgnoreNonTypeDependent && !E->isTypeDependent())
      return true;
  return super::TraverseStmt(S, Q);
}

bool TraverseTypeLoc(TypeLoc TL) {
  if (IgnoreNonTypeDependent && !TL.isNull() &&
      !TL.getType()->isDependentType())
    return true;
  return super::TraverseTypeLoc(TL);
}

bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
  return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
}

bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
  // For a best-effort search, keep looking until we find a location.
  return IgnoreNonTypeDependent || !Matches(T->getDepth());
}

bool TraverseTemplateName(TemplateName N) {
  if (TemplateTemplateParmDecl *PD =
        dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
    if (Matches(PD->getDepth()))
      return false;
  return super::TraverseTemplateName(N);
}

bool VisitDeclRefExpr(DeclRefExpr *E) {
  if (NonTypeTemplateParmDecl *PD =
        dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
    if (Matches(PD->getDepth(), E->getExprLoc()))
      return false;
  return super::VisitDeclRefExpr(E);
}

bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
  return TraverseType(T->getReplacementType());
}

bool
VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
  return TraverseTemplateArgument(T->getArgumentPack());
}

bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
  return TraverseType(T->getInjectedSpecializationType());
}
2988};
2989} // end anonymous namespace

2991/// Determines whether a given type depends on the given parameter
2992/// list.
2993static bool
2994DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) {
if (!Params->size())
  return false;

DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
Checker.TraverseType(T);
return Checker.Match;
3001}

3003// Find the source range corresponding to the named type in the given
3004// nested-name-specifier, if any.
3005static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context,
                                                     QualType T,
                                                     const CXXScopeSpec &SS) {
NestedNameSpecifierLoc NNSLoc(SS.getScopeRep(), SS.location_data());
while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
  if (const Type *CurType = NNS->getAsType()) {
    if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
      return NNSLoc.getTypeLoc().getSourceRange();
  } else
    break;

  NNSLoc = NNSLoc.getPrefix();
}

return SourceRange();
3020}

3022/// Match the given template parameter lists to the given scope
3023/// specifier, returning the template parameter list that applies to the
3024/// name.
3025///
3026/// \param DeclStartLoc the start of the declaration that has a scope
3027/// specifier or a template parameter list.
3028///
3029/// \param DeclLoc The location of the declaration itself.
3030///
3031/// \param SS the scope specifier that will be matched to the given template
3032/// parameter lists. This scope specifier precedes a qualified name that is
3033/// being declared.
3034///
3035/// \param TemplateId The template-id following the scope specifier, if there
3036/// is one. Used to check for a missing 'template<>'.
3037///
3038/// \param ParamLists the template parameter lists, from the outermost to the
3039/// innermost template parameter lists.
3040///
3041/// \param IsFriend Whether to apply the slightly different rules for
3042/// matching template parameters to scope specifiers in friend
3043/// declarations.
3044///
3045/// \param IsMemberSpecialization will be set true if the scope specifier
3046/// denotes a fully-specialized type, and therefore this is a declaration of
3047/// a member specialization.
3048///
3049/// \returns the template parameter list, if any, that corresponds to the
3050/// name that is preceded by the scope specifier @p SS. This template
3051/// parameter list may have template parameters (if we're declaring a
3052/// template) or may have no template parameters (if we're declaring a
3053/// template specialization), or may be NULL (if what we're declaring isn't
3054/// itself a template).
3055TemplateParameterList *Sema::MatchTemplateParametersToScopeSpecifier(
  SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
  TemplateIdAnnotation *TemplateId,
  ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
  bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic) {
IsMemberSpecialization = false;
Invalid = false;

// The sequence of nested types to which we will match up the template
// parameter lists. We first build this list by starting with the type named
// by the nested-name-specifier and walking out until we run out of types.
SmallVector<QualType, 4> NestedTypes;
QualType T;
if (SS.getScopeRep()) {
  if (CXXRecordDecl *Record
            = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
    T = Context.getTypeDeclType(Record);
  else
    T = QualType(SS.getScopeRep()->getAsType(), 0);
}

// If we found an explicit specialization that prevents us from needing
// 'template<>' headers, this will be set to the location of that
// explicit specialization.
SourceLocation ExplicitSpecLoc;

while (!T.isNull()) {
  NestedTypes.push_back(T);

  // Retrieve the parent of a record type.
  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
    // If this type is an explicit specialization, we're done.
    if (ClassTemplateSpecializationDecl *Spec
        = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
      if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
          Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
        ExplicitSpecLoc = Spec->getLocation();
        break;
      }
    } else if (Record->getTemplateSpecializationKind()
                                              == TSK_ExplicitSpecialization) {
      ExplicitSpecLoc = Record->getLocation();
      break;
    }

    if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
      T = Context.getTypeDeclType(Parent);
    else
      T = QualType();
    continue;
  }

  if (const TemplateSpecializationType *TST
                                   = T->getAs<TemplateSpecializationType>()) {
    if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
      if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
        T = Context.getTypeDeclType(Parent);
      else
        T = QualType();
      continue;
    }
  }

  // Look one step prior in a dependent template specialization type.
  if (const DependentTemplateSpecializationType *DependentTST
                        = T->getAs<DependentTemplateSpecializationType>()) {
    if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
      T = QualType(NNS->getAsType(), 0);
    else
      T = QualType();
    continue;
  }

  // Look one step prior in a dependent name type.
  if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
    if (NestedNameSpecifier *NNS = DependentName->getQualifier())
      T = QualType(NNS->getAsType(), 0);
    else
      T = QualType();
    continue;
  }

  // Retrieve the parent of an enumeration type.
  if (const EnumType *EnumT = T->getAs<EnumType>()) {
    // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
    // check here.
    EnumDecl *Enum = EnumT->getDecl();

    // Get to the parent type.
    if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
      T = Context.getTypeDeclType(Parent);
    else
      T = QualType();
    continue;
  }

  T = QualType();
}
// Reverse the nested types list, since we want to traverse from the outermost
// to the innermost while checking template-parameter-lists.
std::reverse(NestedTypes.begin(), NestedTypes.end());

// C++0x [temp.expl.spec]p17:
//   A member or a member template may be nested within many
//   enclosing class templates. In an explicit specialization for
//   such a member, the member declaration shall be preceded by a
//   template<> for each enclosing class template that is
//   explicitly specialized.
bool SawNonEmptyTemplateParameterList = false;

auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
  if (SawNonEmptyTemplateParameterList) {
    if (!SuppressDiagnostic)
      Diag(DeclLoc, diag::err_specialize_member_of_template)
        << !Recovery << Range;
    Invalid = true;
    IsMemberSpecialization = false;
    return true;
  }

  return false;
};

auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
  // Check that we can have an explicit specialization here.
  if (CheckExplicitSpecialization(Range, true))
    return true;

  // We don't have a template header, but we should.
  SourceLocation ExpectedTemplateLoc;
  if (!ParamLists.empty())
    ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
  else
    ExpectedTemplateLoc = DeclStartLoc;

  if (!SuppressDiagnostic)
    Diag(DeclLoc, diag::err_template_spec_needs_header)
      << Range
      << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
  return false;
};

unsigned ParamIdx = 0;
for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
     ++TypeIdx) {
  T = NestedTypes[TypeIdx];

  // Whether we expect a 'template<>' header.
  bool NeedEmptyTemplateHeader = false;

  // Whether we expect a template header with parameters.
  bool NeedNonemptyTemplateHeader = false;

  // For a dependent type, the set of template parameters that we
  // expect to see.
  TemplateParameterList *ExpectedTemplateParams = nullptr;

  // C++0x [temp.expl.spec]p15:
  //   A member or a member template may be nested within many enclosing
  //   class templates. In an explicit specialization for such a member, the
  //   member declaration shall be preceded by a template<> for each
  //   enclosing class template that is explicitly specialized.
  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
    if (ClassTemplatePartialSpecializationDecl *Partial
          = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
      ExpectedTemplateParams = Partial->getTemplateParameters();
      NeedNonemptyTemplateHeader = true;
    } else if (Record->isDependentType()) {
      if (Record->getDescribedClassTemplate()) {
        ExpectedTemplateParams = Record->getDescribedClassTemplate()
                                                    ->getTemplateParameters();
        NeedNonemptyTemplateHeader = true;
      }
    } else if (ClassTemplateSpecializationDecl *Spec
                   = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
      // C++0x [temp.expl.spec]p4:
      //   Members of an explicitly specialized class template are defined
      //   in the same manner as members of normal classes, and not using
      //   the template<> syntax.
      if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
        NeedEmptyTemplateHeader = true;
      else
        continue;
    } else if (Record->getTemplateSpecializationKind()) {
      if (Record->getTemplateSpecializationKind()
                                              != TSK_ExplicitSpecialization &&
          TypeIdx == NumTypes - 1)
        IsMemberSpecialization = true;

      continue;
    }
  } else if (const TemplateSpecializationType *TST
                                   = T->getAs<TemplateSpecializationType>()) {
    if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
      ExpectedTemplateParams = Template->getTemplateParameters();
      NeedNonemptyTemplateHeader = true;
    }
  } else if (T->getAs<DependentTemplateSpecializationType>()) {
    // FIXME:  We actually could/should check the template arguments here
    // against the corresponding template parameter list.
    NeedNonemptyTemplateHeader = false;
  }

  // C++ [temp.expl.spec]p16:
  //   In an explicit specialization declaration for a member of a class
  //   template or a member template that ap- pears in namespace scope, the
  //   member template and some of its enclosing class templates may remain
  //   unspecialized, except that the declaration shall not explicitly
  //   specialize a class member template if its en- closing class templates
  //   are not explicitly specialized as well.
  if (ParamIdx < ParamLists.size()) {
    if (ParamLists[ParamIdx]->size() == 0) {
      if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
                                      false))
        return nullptr;
    } else
      SawNonEmptyTemplateParameterList = true;
  }

  if (NeedEmptyTemplateHeader) {
    // If we're on the last of the types, and we need a 'template<>' header
    // here, then it's a member specialization.
    if (TypeIdx == NumTypes - 1)
      IsMemberSpecialization = true;

    if (ParamIdx < ParamLists.size()) {
      if (ParamLists[ParamIdx]->size() > 0) {
        // The header has template parameters when it shouldn't. Complain.
        if (!SuppressDiagnostic)
          Diag(ParamLists[ParamIdx]->getTemplateLoc(),
               diag::err_template_param_list_matches_nontemplate)
            << T
            << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
                           ParamLists[ParamIdx]->getRAngleLoc())
            << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
        Invalid = true;
        return nullptr;
      }

      // Consume this template header.
      ++ParamIdx;
      continue;
    }

    if (!IsFriend)
      if (DiagnoseMissingExplicitSpecialization(
              getRangeOfTypeInNestedNameSpecifier(Context, T, SS)))
        return nullptr;

    continue;
  }

  if (NeedNonemptyTemplateHeader) {
    // In friend declarations we can have template-ids which don't
    // depend on the corresponding template parameter lists.  But
    // assume that empty parameter lists are supposed to match this
    // template-id.
    if (IsFriend && T->isDependentType()) {
      if (ParamIdx < ParamLists.size() &&
          DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
        ExpectedTemplateParams = nullptr;
      else
        continue;
    }

    if (ParamIdx < ParamLists.size()) {
      // Check the template parameter list, if we can.
      if (ExpectedTemplateParams &&
          !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
                                          ExpectedTemplateParams,
                                          !SuppressDiagnostic, TPL_TemplateMatch))
        Invalid = true;

      if (!Invalid &&
          CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
                                     TPC_ClassTemplateMember))
        Invalid = true;

      ++ParamIdx;
      continue;
    }

    if (!SuppressDiagnostic)
      Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
        << T
        << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
    Invalid = true;
    continue;
  }
}

// If there were at least as many template-ids as there were template
// parameter lists, then there are no template parameter lists remaining for
// the declaration itself.
if (ParamIdx >= ParamLists.size()) {
  if (TemplateId && !IsFriend) {
    // We don't have a template header for the declaration itself, but we
    // should.
    DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
                                                      TemplateId->RAngleLoc));

    // Fabricate an empty template parameter list for the invented header.
    return TemplateParameterList::Create(Context, SourceLocation(),
                                         SourceLocation(), None,
                                         SourceLocation(), nullptr);
  }

  return nullptr;
}

// If there were too many template parameter lists, complain about that now.
if (ParamIdx < ParamLists.size() - 1) {
  bool HasAnyExplicitSpecHeader = false;
  bool AllExplicitSpecHeaders = true;
  for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
    if (ParamLists[I]->size() == 0)
      HasAnyExplicitSpecHeader = true;
    else
      AllExplicitSpecHeaders = false;
  }

  if (!SuppressDiagnostic)
    Diag(ParamLists[ParamIdx]->getTemplateLoc(),
         AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
                                : diag::err_template_spec_extra_headers)
        << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
                       ParamLists[ParamLists.size() - 2]->getRAngleLoc());

  // If there was a specialization somewhere, such that 'template<>' is
  // not required, and there were any 'template<>' headers, note where the
  // specialization occurred.
  if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader &&
      !SuppressDiagnostic)
    Diag(ExplicitSpecLoc,
         diag::note_explicit_template_spec_does_not_need_header)
      << NestedTypes.back();

  // We have a template parameter list with no corresponding scope, which
  // means that the resulting template declaration can't be instantiated
  // properly (we'll end up with dependent nodes when we shouldn't).
  if (!AllExplicitSpecHeaders)
    Invalid = true;
}

// C++ [temp.expl.spec]p16:
//   In an explicit specialization declaration for a member of a class
//   template or a member template that ap- pears in namespace scope, the
//   member template and some of its enclosing class templates may remain
//   unspecialized, except that the declaration shall not explicitly
//   specialize a class member template if its en- closing class templates
//   are not explicitly specialized as well.
if (ParamLists.back()->size() == 0 &&
    CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
                                false))
  return nullptr;

// Return the last template parameter list, which corresponds to the
// entity being declared.
return ParamLists.back();
3414}

3416void Sema::NoteAllFoundTemplates(TemplateName Name) {
if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
  Diag(Template->getLocation(), diag::note_template_declared_here)
      << (isa<FunctionTemplateDecl>(Template)
              ? 0
              : isa<ClassTemplateDecl>(Template)
                    ? 1
                    : isa<VarTemplateDecl>(Template)
                          ? 2
                          : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
      << Template->getDeclName();
  return;
}

if (OverloadedTemplateStorage *OST = Name.getAsOverloadedTemplate()) {
  for (OverloadedTemplateStorage::iterator I = OST->begin(),
                                        IEnd = OST->end();
       I != IEnd; ++I)
    Diag((*I)->getLocation(), diag::note_template_declared_here)
      << 0 << (*I)->getDeclName();

  return;
}
3439}

3441static QualType
3442checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
                         const SmallVectorImpl<TemplateArgument> &Converted,
                         SourceLocation TemplateLoc,
                         TemplateArgumentListInfo &TemplateArgs) {
ASTContext &Context = SemaRef.getASTContext();
switch (BTD->getBuiltinTemplateKind()) {
case BTK__make_integer_seq: {
  // Specializations of __make_integer_seq<S, T, N> are treated like
  // S<T, 0, ..., N-1>.

  // C++14 [inteseq.intseq]p1:
  //   T shall be an integer type.
  if (!Converted[1].getAsType()->isIntegralType(Context)) {
    SemaRef.Diag(TemplateArgs[1].getLocation(),
                 diag::err_integer_sequence_integral_element_type);
    return QualType();
  }

  // C++14 [inteseq.make]p1:
  //   If N is negative the program is ill-formed.
  TemplateArgument NumArgsArg = Converted[2];
  llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
  if (NumArgs < 0) {
    SemaRef.Diag(TemplateArgs[2].getLocation(),
                 diag::err_integer_sequence_negative_length);
    return QualType();
  }

  QualType ArgTy = NumArgsArg.getIntegralType();
  TemplateArgumentListInfo SyntheticTemplateArgs;
  // The type argument gets reused as the first template argument in the
  // synthetic template argument list.
  SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
  // Expand N into 0 ... N-1.
  for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
       I < NumArgs; ++I) {
    TemplateArgument TA(Context, I, ArgTy);
    SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
        TA, ArgTy, TemplateArgs[2].getLocation()));
  }
  // The first template argument will be reused as the template decl that
  // our synthetic template arguments will be applied to.
  return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
                                     TemplateLoc, SyntheticTemplateArgs);
}

case BTK__type_pack_element:
  // Specializations of
  //    __type_pack_element<Index, T_1, ..., T_N>
  // are treated like T_Index.
  assert(Converted.size() == 2 &&((void)0)
    "__type_pack_element should be given an index and a parameter pack")((void)0);

  // If the Index is out of bounds, the program is ill-formed.
  TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
  llvm::APSInt Index = IndexArg.getAsIntegral();
  assert(Index >= 0 && "the index used with __type_pack_element should be of "((void)0)
                       "type std::size_t, and hence be non-negative")((void)0);
  if (Index >= Ts.pack_size()) {
    SemaRef.Diag(TemplateArgs[0].getLocation(),
                 diag::err_type_pack_element_out_of_bounds);
    return QualType();
  }

  // We simply return the type at index `Index`.
  auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
  return Nth->getAsType();
}
llvm_unreachable("unexpected BuiltinTemplateDecl!")__builtin_unreachable();
3511}

3513/// Determine whether this alias template is "enable_if_t".
3514static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
return AliasTemplate->getName().equals("enable_if_t");
3516}

3518/// Collect all of the separable terms in the given condition, which
3519/// might be a conjunction.
3520///
3521/// FIXME: The right answer is to convert the logical expression into
3522/// disjunctive normal form, so we can find the first failed term
3523/// within each possible clause.
3524static void collectConjunctionTerms(Expr *Clause,
                                  SmallVectorImpl<Expr *> &Terms) {
if (auto BinOp = dyn_cast<BinaryOperator>(Clause->IgnoreParenImpCasts())) {
  if (BinOp->getOpcode() == BO_LAnd) {
    collectConjunctionTerms(BinOp->getLHS(), Terms);
    collectConjunctionTerms(BinOp->getRHS(), Terms);
  }

  return;
}

Terms.push_back(Clause);
3536}

3538// The ranges-v3 library uses an odd pattern of a top-level "||" with
3539// a left-hand side that is value-dependent but never true. Identify
3540// the idiom and ignore that term.
3541static Expr *lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond) {
// Top-level '||'.
auto *BinOp = dyn_cast<BinaryOperator>(Cond->IgnoreParenImpCasts());
if (!BinOp) return Cond;

if (BinOp->getOpcode() != BO_LOr) return Cond;

// With an inner '==' that has a literal on the right-hand side.
Expr *LHS = BinOp->getLHS();
auto *InnerBinOp = dyn_cast<BinaryOperator>(LHS->IgnoreParenImpCasts());
if (!InnerBinOp) return Cond;

if (InnerBinOp->getOpcode() != BO_EQ ||
    !isa<IntegerLiteral>(InnerBinOp->getRHS()))
  return Cond;

// If the inner binary operation came from a macro expansion named
// CONCEPT_REQUIRES or CONCEPT_REQUIRES_, return the right-hand side
// of the '||', which is the real, user-provided condition.
SourceLocation Loc = InnerBinOp->getExprLoc();
if (!Loc.isMacroID()) return Cond;

StringRef MacroName = PP.getImmediateMacroName(Loc);
if (MacroName == "CONCEPT_REQUIRES" || MacroName == "CONCEPT_REQUIRES_")
  return BinOp->getRHS();

return Cond;
3568}

3570namespace {

3572// A PrinterHelper that prints more helpful diagnostics for some sub-expressions
3573// within failing boolean expression, such as substituting template parameters
3574// for actual types.
3575class FailedBooleanConditionPrinterHelper : public PrinterHelper {
3576public:
explicit FailedBooleanConditionPrinterHelper(const PrintingPolicy &P)
    : Policy(P) {}

bool handledStmt(Stmt *E, raw_ostream &OS) override {
  const auto *DR = dyn_cast<DeclRefExpr>(E);
  if (DR && DR->getQualifier()) {
    // If this is a qualified name, expand the template arguments in nested
    // qualifiers.
    DR->getQualifier()->print(OS, Policy, true);
    // Then print the decl itself.
    const ValueDecl *VD = DR->getDecl();
    OS << VD->getName();
    if (const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
      // This is a template variable, print the expanded template arguments.
      printTemplateArgumentList(
          OS, IV->getTemplateArgs().asArray(), Policy,
          IV->getSpecializedTemplate()->getTemplateParameters());
    }
    return true;
  }
  return false;
}

3600private:
const PrintingPolicy Policy;
3602};

3604} // end anonymous namespace

3606std::pair<Expr *, std::string>
3607Sema::findFailedBooleanCondition(Expr *Cond) {
Cond = lookThroughRangesV3Condition(PP, Cond);

// Separate out all of the terms in a conjunction.
SmallVector<Expr *, 4> Terms;
collectConjunctionTerms(Cond, Terms);

// Determine which term failed.
Expr *FailedCond = nullptr;
for (Expr *Term : Terms) {
  Expr *TermAsWritten = Term->IgnoreParenImpCasts();

  // Literals are uninteresting.
  if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
      isa<IntegerLiteral>(TermAsWritten))
    continue;

  // The initialization of the parameter from the argument is
  // a constant-evaluated context.
  EnterExpressionEvaluationContext ConstantEvaluated(
    *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  bool Succeeded;
  if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
      !Succeeded) {
    FailedCond = TermAsWritten;
    break;
  }
}
if (!FailedCond)
  FailedCond = Cond->IgnoreParenImpCasts();

std::string Description;
{
  llvm::raw_string_ostream Out(Description);
  PrintingPolicy Policy = getPrintingPolicy();
  Policy.PrintCanonicalTypes = true;
  FailedBooleanConditionPrinterHelper Helper(Policy);
  FailedCond->printPretty(Out, &Helper, Policy, 0, "\n", nullptr);
}
return { FailedCond, Description };
3648}

3650QualType Sema::CheckTemplateIdType(TemplateName Name,
                                 SourceLocation TemplateLoc,
                                 TemplateArgumentListInfo &TemplateArgs) {
DependentTemplateName *DTN
  = Name.getUnderlying().getAsDependentTemplateName();
if (DTN && DTN->isIdentifier())
  // When building a template-id where the template-name is dependent,
  // assume the template is a type template. Either our assumption is
  // correct, or the code is ill-formed and will be diagnosed when the
  // dependent name is substituted.
  return Context.getDependentTemplateSpecializationType(ETK_None,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                        TemplateArgs);

if (Name.getAsAssumedTemplateName() &&
    resolveAssumedTemplateNameAsType(/*Scope*/nullptr, Name, TemplateLoc))
  return QualType();

TemplateDecl *Template = Name.getAsTemplateDecl();
if (!Template || isa<FunctionTemplateDecl>(Template) ||
    isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
  // We might have a substituted template template parameter pack. If so,
  // build a template specialization type for it.
  if (Name.getAsSubstTemplateTemplateParmPack())
    return Context.getTemplateSpecializationType(Name, TemplateArgs);

  Diag(TemplateLoc, diag::err_template_id_not_a_type)
    << Name;
  NoteAllFoundTemplates(Name);
  return QualType();
}

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
                              false, Converted,
                              /*UpdateArgsWithConversion=*/true))
  return QualType();

QualType CanonType;

if (TypeAliasTemplateDecl *AliasTemplate =
        dyn_cast<TypeAliasTemplateDecl>(Template)) {

  // Find the canonical type for this type alias template specialization.
  TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
  if (Pattern->isInvalidDecl())
    return QualType();

  TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
                                         Converted);

  // Only substitute for the innermost template argument list.
  MultiLevelTemplateArgumentList TemplateArgLists;
  TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
  TemplateArgLists.addOuterRetainedLevels(
      AliasTemplate->getTemplateParameters()->getDepth());

  LocalInstantiationScope Scope(*this);
  InstantiatingTemplate Inst(*this, TemplateLoc, Template);
  if (Inst.isInvalid())
    return QualType();

  CanonType = SubstType(Pattern->getUnderlyingType(),
                        TemplateArgLists, AliasTemplate->getLocation(),
                        AliasTemplate->getDeclName());
  if (CanonType.isNull()) {
    // If this was enable_if and we failed to find the nested type
    // within enable_if in a SFINAE context, dig out the specific
    // enable_if condition that failed and present that instead.
    if (isEnableIfAliasTemplate(AliasTemplate)) {
      if (auto DeductionInfo = isSFINAEContext()) {
        if (*DeductionInfo &&
            (*DeductionInfo)->hasSFINAEDiagnostic() &&
            (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
              diag::err_typename_nested_not_found_enable_if &&
            TemplateArgs[0].getArgument().getKind()
              == TemplateArgument::Expression) {
          Expr *FailedCond;
          std::string FailedDescription;
          std::tie(FailedCond, FailedDescription) =
            findFailedBooleanCondition(TemplateArgs[0].getSourceExpression());

          // Remove the old SFINAE diagnostic.
          PartialDiagnosticAt OldDiag =
            {SourceLocation(), PartialDiagnostic::NullDiagnostic()};
          (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);

          // Add a new SFINAE diagnostic specifying which condition
          // failed.
          (*DeductionInfo)->addSFINAEDiagnostic(
            OldDiag.first,
            PDiag(diag::err_typename_nested_not_found_requirement)
              << FailedDescription
              << FailedCond->getSourceRange());
        }
      }
    }

    return QualType();
  }
} else if (Name.isDependent() ||
           TemplateSpecializationType::anyDependentTemplateArguments(
               TemplateArgs, Converted)) {
  // This class template specialization is a dependent
  // type. Therefore, its canonical type is another class template
  // specialization type that contains all of the converted
  // arguments in canonical form. This ensures that, e.g., A<T> and
  // A<T, T> have identical types when A is declared as:
  //
  //   template<typename T, typename U = T> struct A;
  CanonType = Context.getCanonicalTemplateSpecializationType(Name, Converted);

  // This might work out to be a current instantiation, in which
  // case the canonical type needs to be the InjectedClassNameType.
  //
  // TODO: in theory this could be a simple hashtable lookup; most
  // changes to CurContext don't change the set of current
  // instantiations.
  if (isa<ClassTemplateDecl>(Template)) {
    for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
      // If we get out to a namespace, we're done.
      if (Ctx->isFileContext()) break;

      // If this isn't a record, keep looking.
      CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
      if (!Record) continue;

      // Look for one of the two cases with InjectedClassNameTypes
      // and check whether it's the same template.
      if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
          !Record->getDescribedClassTemplate())
        continue;

      // Fetch the injected class name type and check whether its
      // injected type is equal to the type we just built.
      QualType ICNT = Context.getTypeDeclType(Record);
      QualType Injected = cast<InjectedClassNameType>(ICNT)
        ->getInjectedSpecializationType();

      if (CanonType != Injected->getCanonicalTypeInternal())
        continue;

      // If so, the canonical type of this TST is the injected
      // class name type of the record we just found.
      assert(ICNT.isCanonical())((void)0);
      CanonType = ICNT;
      break;
    }
  }
} else if (ClassTemplateDecl *ClassTemplate
             = dyn_cast<ClassTemplateDecl>(Template)) {
  // Find the class template specialization declaration that
  // corresponds to these arguments.
  void *InsertPos = nullptr;
  ClassTemplateSpecializationDecl *Decl
    = ClassTemplate->findSpecialization(Converted, InsertPos);
  if (!Decl) {
    // This is the first time we have referenced this class template
    // specialization. Create the canonical declaration and add it to
    // the set of specializations.
    Decl = ClassTemplateSpecializationDecl::Create(
        Context, ClassTemplate->getTemplatedDecl()->getTagKind(),
        ClassTemplate->getDeclContext(),
        ClassTemplate->getTemplatedDecl()->getBeginLoc(),
        ClassTemplate->getLocation(), ClassTemplate, Converted, nullptr);
    ClassTemplate->AddSpecialization(Decl, InsertPos);
    if (ClassTemplate->isOutOfLine())
      Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
  }

  if (Decl->getSpecializationKind() == TSK_Undeclared &&
      ClassTemplate->getTemplatedDecl()->hasAttrs()) {
    InstantiatingTemplate Inst(*this, TemplateLoc, Decl);
    if (!Inst.isInvalid()) {
      MultiLevelTemplateArgumentList TemplateArgLists;
      TemplateArgLists.addOuterTemplateArguments(Converted);
      InstantiateAttrsForDecl(TemplateArgLists,
                              ClassTemplate->getTemplatedDecl(), Decl);
    }
  }

  // Diagnose uses of this specialization.
  (void)DiagnoseUseOfDecl(Decl, TemplateLoc);

  CanonType = Context.getTypeDeclType(Decl);
  assert(isa<RecordType>(CanonType) &&((void)0)
         "type of non-dependent specialization is not a RecordType")((void)0);
} else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
  CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
                                         TemplateArgs);
}

// Build the fully-sugared type for this class template
// specialization, which refers back to the class template
// specialization we created or found.
return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
3849}

3851void Sema::ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &ParsedName,
                                         TemplateNameKind &TNK,
                                         SourceLocation NameLoc,
                                         IdentifierInfo *&II) {
assert(TNK == TNK_Undeclared_template && "not an undeclared template name")((void)0);

TemplateName Name = ParsedName.get();
auto *ATN = Name.getAsAssumedTemplateName();
assert(ATN && "not an assumed template name")((void)0);
II = ATN->getDeclName().getAsIdentifierInfo();

if (!resolveAssumedTemplateNameAsType(S, Name, NameLoc, /*Diagnose*/false)) {
  // Resolved to a type template name.
  ParsedName = TemplateTy::make(Name);
  TNK = TNK_Type_template;
}
3867}

3869bool Sema::resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
                                          SourceLocation NameLoc,
                                          bool Diagnose) {
// We assumed this undeclared identifier to be an (ADL-only) function
// template name, but it was used in a context where a type was required.
// Try to typo-correct it now.
AssumedTemplateStorage *ATN = Name.getAsAssumedTemplateName();
assert(ATN && "not an assumed template name")((void)0);

LookupResult R(*this, ATN->getDeclName(), NameLoc, LookupOrdinaryName);
struct CandidateCallback : CorrectionCandidateCallback {
  bool ValidateCandidate(const TypoCorrection &TC) override {
    return TC.getCorrectionDecl() &&
           getAsTypeTemplateDecl(TC.getCorrectionDecl());
  }
  std::unique_ptr<CorrectionCandidateCallback> clone() override {
    return std::make_unique<CandidateCallback>(*this);
  }
} FilterCCC;

TypoCorrection Corrected =
    CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
                FilterCCC, CTK_ErrorRecovery);
if (Corrected && Corrected.getFoundDecl()) {
  diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest)
                              << ATN->getDeclName());
  Name = TemplateName(Corrected.getCorrectionDeclAs<TemplateDecl>());
  return false;
}

if (Diagnose)
  Diag(R.getNameLoc(), diag::err_no_template) << R.getLookupName();
return true;
3902}

3904TypeResult Sema::ActOnTemplateIdType(
  Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
  TemplateTy TemplateD, IdentifierInfo *TemplateII,
  SourceLocation TemplateIILoc, SourceLocation LAngleLoc,
  ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc,
  bool IsCtorOrDtorName, bool IsClassName) {
if (SS.isInvalid())
  return true;

if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {
  DeclContext *LookupCtx = computeDeclContext(SS, /*EnteringContext*/false);

  // C++ [temp.res]p3:
  //   A qualified-id that refers to a type and in which the
  //   nested-name-specifier depends on a template-parameter (14.6.2)
  //   shall be prefixed by the keyword typename to indicate that the
  //   qualified-id denotes a type, forming an
  //   elaborated-type-specifier (7.1.5.3).
  if (!LookupCtx && isDependentScopeSpecifier(SS)) {
    Diag(SS.getBeginLoc(), diag::err_typename_missing_template)
      << SS.getScopeRep() << TemplateII->getName();
    // Recover as if 'typename' were specified.
    // FIXME: This is not quite correct recovery as we don't transform SS
    // into the corresponding dependent form (and we don't diagnose missing
    // 'template' keywords within SS as a result).
    return ActOnTypenameType(nullptr, SourceLocation(), SS, TemplateKWLoc,
                             TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
                             TemplateArgsIn, RAngleLoc);
  }

  // Per C++ [class.qual]p2, if the template-id was an injected-class-name,
  // it's not actually allowed to be used as a type in most cases. Because
  // we annotate it before we know whether it's valid, we have to check for
  // this case here.
  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
    Diag(TemplateIILoc,
         TemplateKWLoc.isInvalid()
             ? diag::err_out_of_line_qualified_id_type_names_constructor
             : diag::ext_out_of_line_qualified_id_type_names_constructor)
      << TemplateII << 0 /*injected-class-name used as template name*/
      << 1 /*if any keyword was present, it was 'template'*/;
  }
}

TemplateName Template = TemplateD.get();
if (Template.getAsAssumedTemplateName() &&
    resolveAssumedTemplateNameAsType(S, Template, TemplateIILoc))
  return true;

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

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType T
    = Context.getDependentTemplateSpecializationType(ETK_None,
                                                     DTN->getQualifier(),
                                                     DTN->getIdentifier(),
                                                     TemplateArgs);
  // Build type-source information.
  TypeLocBuilder TLB;
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(SourceLocation());
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateIILoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
}

QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
if (Result.isNull())
  return true;

// Build type-source information.
TypeLocBuilder TLB;
TemplateSpecializationTypeLoc SpecTL
  = TLB.push<TemplateSpecializationTypeLoc>(Result);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateIILoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());

// NOTE: avoid constructing an ElaboratedTypeLoc if this is a
// constructor or destructor name (in such a case, the scope specifier
// will be attached to the enclosing Decl or Expr node).
if (SS.isNotEmpty() && !IsCtorOrDtorName) {
  // Create an elaborated-type-specifier containing the nested-name-specifier.
  Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
  ElabTL.setElaboratedKeywordLoc(SourceLocation());
  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
}

return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
4006}

4008TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
                                      TypeSpecifierType TagSpec,
                                      SourceLocation TagLoc,
                                      CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      TemplateTy TemplateD,
                                      SourceLocation TemplateLoc,
                                      SourceLocation LAngleLoc,
                                      ASTTemplateArgsPtr TemplateArgsIn,
                                      SourceLocation RAngleLoc) {
if (SS.isInvalid())
  return TypeResult(true);

TemplateName Template = TemplateD.get();

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

// Determine the tag kind
TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
ElaboratedTypeKeyword Keyword
  = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType T = Context.getDependentTemplateSpecializationType(Keyword,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                              TemplateArgs);

  // Build type-source information.
  TypeLocBuilder TLB;
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(TagLoc);
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateLoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
}

if (TypeAliasTemplateDecl *TAT =
      dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
  // C++0x [dcl.type.elab]p2:
  //   If the identifier resolves to a typedef-name or the simple-template-id
  //   resolves to an alias template specialization, the
  //   elaborated-type-specifier is ill-formed.
  Diag(TemplateLoc, diag::err_tag_reference_non_tag)
      << TAT << NTK_TypeAliasTemplate << TagKind;
  Diag(TAT->getLocation(), diag::note_declared_at);
}

QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
if (Result.isNull())
  return TypeResult(true);

// Check the tag kind
if (const RecordType *RT = Result->getAs<RecordType>()) {
  RecordDecl *D = RT->getDecl();

  IdentifierInfo *Id = D->getIdentifier();
  assert(Id && "templated class must have an identifier")((void)0);

  if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
                                    TagLoc, Id)) {
    Diag(TagLoc, diag::err_use_with_wrong_tag)
      << Result
      << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());
    Diag(D->getLocation(), diag::note_previous_use);
  }
}

// Provide source-location information for the template specialization.
TypeLocBuilder TLB;
TemplateSpecializationTypeLoc SpecTL
  = TLB.push<TemplateSpecializationTypeLoc>(Result);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateLoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());

// Construct an elaborated type containing the nested-name-specifier (if any)
// and tag keyword.
Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
ElabTL.setElaboratedKeywordLoc(TagLoc);
ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
4102}

4104static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
                                           NamedDecl *PrevDecl,
                                           SourceLocation Loc,
                                           bool IsPartialSpecialization);

4109static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);

4111static bool isTemplateArgumentTemplateParameter(
  const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
switch (Arg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::NullPtr:
case TemplateArgument::Integral:
case TemplateArgument::Declaration:
case TemplateArgument::Pack:
case TemplateArgument::TemplateExpansion:
  return false;

case TemplateArgument::Type: {
  QualType Type = Arg.getAsType();
  const TemplateTypeParmType *TPT =
      Arg.getAsType()->getAs<TemplateTypeParmType>();
  return TPT && !Type.hasQualifiers() &&
         TPT->getDepth() == Depth && TPT->getIndex() == Index;
}

case TemplateArgument::Expression: {
  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
  if (!DRE || !DRE->getDecl())
    return false;
  const NonTypeTemplateParmDecl *NTTP =
      dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
  return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
}

case TemplateArgument::Template:
  const TemplateTemplateParmDecl *TTP =
      dyn_cast_or_null<TemplateTemplateParmDecl>(
          Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl());
  return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
}
llvm_unreachable("unexpected kind of template argument")__builtin_unreachable();
4146}

4148static bool isSameAsPrimaryTemplate(TemplateParameterList *Params,
                                  ArrayRef<TemplateArgument> Args) {
if (Params->size() != Args.size())
  return false;

unsigned Depth = Params->getDepth();

for (unsigned I = 0, N = Args.size(); I != N; ++I) {
  TemplateArgument Arg = Args[I];

  // If the parameter is a pack expansion, the argument must be a pack
  // whose only element is a pack expansion.
  if (Params->getParam(I)->isParameterPack()) {
    if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
        !Arg.pack_begin()->isPackExpansion())
      return false;
    Arg = Arg.pack_begin()->getPackExpansionPattern();
  }

  if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
    return false;
}

return true;
4172}

4174template<typename PartialSpecDecl>
4175static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
if (Partial->getDeclContext()->isDependentContext())
  return;

// FIXME: Get the TDK from deduction in order to provide better diagnostics
// for non-substitution-failure issues?
TemplateDeductionInfo Info(Partial->getLocation());
if (S.isMoreSpecializedThanPrimary(Partial, Info))
  return;

auto *Template = Partial->getSpecializedTemplate();
S.Diag(Partial->getLocation(),
       diag::ext_partial_spec_not_more_specialized_than_primary)
    << isa<VarTemplateDecl>(Template);

if (Info.hasSFINAEDiagnostic()) {
  PartialDiagnosticAt Diag = {SourceLocation(),
                              PartialDiagnostic::NullDiagnostic()};
  Info.takeSFINAEDiagnostic(Diag);
  SmallString<128> SFINAEArgString;
  Diag.second.EmitToString(S.getDiagnostics(), SFINAEArgString);
  S.Diag(Diag.first,
         diag::note_partial_spec_not_more_specialized_than_primary)
    << SFINAEArgString;
}

S.Diag(Template->getLocation(), diag::note_template_decl_here);
SmallVector<const Expr *, 3> PartialAC, TemplateAC;
Template->getAssociatedConstraints(TemplateAC);
Partial->getAssociatedConstraints(PartialAC);
S.MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Partial, PartialAC, Template,
                                                TemplateAC);
4207}

4209static void
4210noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams,
                         const llvm::SmallBitVector &DeducibleParams) {
for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
  if (!DeducibleParams[I]) {
    NamedDecl *Param = TemplateParams->getParam(I);
    if (Param->getDeclName())
      S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
          << Param->getDeclName();
    else
      S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
          << "(anonymous)";
  }
}
4223}


4226template<typename PartialSpecDecl>
4227static void checkTemplatePartialSpecialization(Sema &S,
                                             PartialSpecDecl *Partial) {
// C++1z [temp.class.spec]p8: (DR1495)
//   - The specialization shall be more specialized than the primary
//     template (14.5.5.2).
checkMoreSpecializedThanPrimary(S, Partial);

// C++ [temp.class.spec]p8: (DR1315)
//   - Each template-parameter shall appear at least once in the
//     template-id outside a non-deduced context.
// C++1z [temp.class.spec.match]p3 (P0127R2)
//   If the template arguments of a partial specialization cannot be
//   deduced because of the structure of its template-parameter-list
//   and the template-id, the program is ill-formed.
auto *TemplateParams = Partial->getTemplateParameters();
llvm::SmallBitVector DeducibleParams(TemplateParams->size());
S.MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
                             TemplateParams->getDepth(), DeducibleParams);

if (!DeducibleParams.all()) {
  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
  S.Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
    << isa<VarTemplatePartialSpecializationDecl>(Partial)
    << (NumNonDeducible > 1)
    << SourceRange(Partial->getLocation(),
                   Partial->getTemplateArgsAsWritten()->RAngleLoc);
  noteNonDeducibleParameters(S, TemplateParams, DeducibleParams);
}
4255}

4257void Sema::CheckTemplatePartialSpecialization(
  ClassTemplatePartialSpecializationDecl *Partial) {
checkTemplatePartialSpecialization(*this, Partial);
4260}

4262void Sema::CheckTemplatePartialSpecialization(
  VarTemplatePartialSpecializationDecl *Partial) {
checkTemplatePartialSpecialization(*this, Partial);
4265}

4267void Sema::CheckDeductionGuideTemplate(FunctionTemplateDecl *TD) {
// C++1z [temp.param]p11:
//   A template parameter of a deduction guide template that does not have a
//   default-argument shall be deducible from the parameter-type-list of the
//   deduction guide template.
auto *TemplateParams = TD->getTemplateParameters();
llvm::SmallBitVector DeducibleParams(TemplateParams->size());
MarkDeducedTemplateParameters(TD, DeducibleParams);
for (unsigned I = 0; I != TemplateParams->size(); ++I) {
  // A parameter pack is deducible (to an empty pack).
  auto *Param = TemplateParams->getParam(I);
  if (Param->isParameterPack() || hasVisibleDefaultArgument(Param))
    DeducibleParams[I] = true;
}

if (!DeducibleParams.all()) {
  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
  Diag(TD->getLocation(), diag::err_deduction_guide_template_not_deducible)
    << (NumNonDeducible > 1);
  noteNonDeducibleParameters(*this, TemplateParams, DeducibleParams);
}
4288}

4290DeclResult Sema::ActOnVarTemplateSpecialization(
  Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
  TemplateParameterList *TemplateParams, StorageClass SC,
  bool IsPartialSpecialization) {
// D must be variable template id.
assert(D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&((void)0)
       "Variable template specialization is declared with a template it.")((void)0);

TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
TemplateArgumentListInfo TemplateArgs =
    makeTemplateArgumentListInfo(*this, *TemplateId);
SourceLocation TemplateNameLoc = D.getIdentifierLoc();
SourceLocation LAngleLoc = TemplateId->LAngleLoc;
SourceLocation RAngleLoc = TemplateId->RAngleLoc;

TemplateName Name = TemplateId->Template.get();

// The template-id must name a variable template.
VarTemplateDecl *VarTemplate =
    dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
if (!VarTemplate) {
  NamedDecl *FnTemplate;
  if (auto *OTS = Name.getAsOverloadedTemplate())
    FnTemplate = *OTS->begin();
  else
    FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
  if (FnTemplate)
    return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
             << FnTemplate->getDeclName();
  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
           << IsPartialSpecialization;
}

// Check for unexpanded parameter packs in any of the template arguments.
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
                                      UPPC_PartialSpecialization))
    return true;

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
                              false, Converted,
                              /*UpdateArgsWithConversion=*/true))
  return true;

// Find the variable template (partial) specialization declaration that
// corresponds to these arguments.
if (IsPartialSpecialization) {
  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
                                             TemplateArgs.size(), Converted))
    return true;

  // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
  // also do them during instantiation.
  if (!Name.isDependent() &&
      !TemplateSpecializationType::anyDependentTemplateArguments(TemplateArgs,
                                                                 Converted)) {
    Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
        << VarTemplate->getDeclName();
    IsPartialSpecialization = false;
  }

  if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
                              Converted) &&
      (!Context.getLangOpts().CPlusPlus20 ||
       !TemplateParams->hasAssociatedConstraints())) {
    // C++ [temp.class.spec]p9b3:
    //
    //   -- The argument list of the specialization shall not be identical
    //      to the implicit argument list of the primary template.
    Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
      << /*variable template*/ 1
      << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
      << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
    // FIXME: Recover from this by treating the declaration as a redeclaration
    // of the primary template.
    return true;
  }
}

void *InsertPos = nullptr;
VarTemplateSpecializationDecl *PrevDecl = nullptr;

if (IsPartialSpecialization)
  PrevDecl = VarTemplate->findPartialSpecialization(Converted, TemplateParams,
                                                    InsertPos);
else
  PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);

VarTemplateSpecializationDecl *Specialization = nullptr;

// Check whether we can declare a variable template specialization in
// the current scope.
if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
                                     TemplateNameLoc,
                                     IsPartialSpecialization))
  return true;

if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
  // Since the only prior variable template specialization with these
  // arguments was referenced but not declared,  reuse that
  // declaration node as our own, updating its source location and
  // the list of outer template parameters to reflect our new declaration.
  Specialization = PrevDecl;
  Specialization->setLocation(TemplateNameLoc);
  PrevDecl = nullptr;
} else if (IsPartialSpecialization) {
  // Create a new class template partial specialization declaration node.
  VarTemplatePartialSpecializationDecl *PrevPartial =
      cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
  VarTemplatePartialSpecializationDecl *Partial =
      VarTemplatePartialSpecializationDecl::Create(
          Context, VarTemplate->getDeclContext(), TemplateKWLoc,
          TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
          Converted, TemplateArgs);

  if (!PrevPartial)
    VarTemplate->AddPartialSpecialization(Partial, InsertPos);
  Specialization = Partial;

  // If we are providing an explicit specialization of a member variable
  // template specialization, make a note of that.
  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
    PrevPartial->setMemberSpecialization();

  CheckTemplatePartialSpecialization(Partial);
} else {
  // Create a new class template specialization declaration node for
  // this explicit specialization or friend declaration.
  Specialization = VarTemplateSpecializationDecl::Create(
      Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
      VarTemplate, DI->getType(), DI, SC, Converted);
  Specialization->setTemplateArgsInfo(TemplateArgs);

  if (!PrevDecl)
    VarTemplate->AddSpecialization(Specialization, InsertPos);
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
  bool Okay = false;
  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
    // Is there any previous explicit specialization declaration?
    if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
      Okay = true;
      break;
    }
  }

  if (!Okay) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
        << Name << Range;

    Diag(PrevDecl->getPointOfInstantiation(),
         diag::note_instantiation_required_here)
        << (PrevDecl->getTemplateSpecializationKind() !=
            TSK_ImplicitInstantiation);
    return true;
  }
}

Specialization->setTemplateKeywordLoc(TemplateKWLoc);
Specialization->setLexicalDeclContext(CurContext);

// Add the specialization into its lexical context, so that it can
// be seen when iterating through the list of declarations in that
// context. However, specializations are not found by name lookup.
CurContext->addDecl(Specialization);

// Note that this is an explicit specialization.
Specialization->setSpecializationKind(TSK_ExplicitSpecialization);

if (PrevDecl) {
  // Check that this isn't a redefinition of this specialization,
  // merging with previous declarations.
  LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
                        forRedeclarationInCurContext());
  PrevSpec.addDecl(PrevDecl);
  D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
} else if (Specialization->isStaticDataMember() &&
           Specialization->isOutOfLine()) {
  Specialization->setAccess(VarTemplate->getAccess());
}

return Specialization;
4483}

4485namespace {
4486/// A partial specialization whose template arguments have matched
4487/// a given template-id.
4488struct PartialSpecMatchResult {
VarTemplatePartialSpecializationDecl *Partial;
TemplateArgumentList *Args;
4491};
4492} // end anonymous namespace

4494DeclResult
4495Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
                       SourceLocation TemplateNameLoc,
                       const TemplateArgumentListInfo &TemplateArgs) {
assert(Template && "A variable template id without template?")((void)0);

// Check that the template argument list is well-formed for this template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(
        Template, TemplateNameLoc,
        const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
        Converted, /*UpdateArgsWithConversion=*/true))
  return true;

// Produce a placeholder value if the specialization is dependent.
if (Template->getDeclContext()->isDependentContext() ||
    TemplateSpecializationType::anyDependentTemplateArguments(TemplateArgs,
                                                              Converted))
  return DeclResult();

// Find the variable template specialization declaration that
// corresponds to these arguments.
void *InsertPos = nullptr;
if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
        Converted, InsertPos)) {
  checkSpecializationVisibility(TemplateNameLoc, Spec);
  // If we already have a variable template specialization, return it.
  return Spec;
}

// This is the first time we have referenced this variable template
// specialization. Create the canonical declaration and add it to
// the set of specializations, based on the closest partial specialization
// that it represents. That is,
VarDecl *InstantiationPattern = Template->getTemplatedDecl();
TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
                                     Converted);
TemplateArgumentList *InstantiationArgs = &TemplateArgList;
bool AmbiguousPartialSpec = false;
typedef PartialSpecMatchResult MatchResult;
SmallVector<MatchResult, 4> Matched;
SourceLocation PointOfInstantiation = TemplateNameLoc;
TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
                                          /*ForTakingAddress=*/false);

// 1. Attempt to find the closest partial specialization that this
// specializes, if any.
// TODO: Unify with InstantiateClassTemplateSpecialization()?
//       Perhaps better after unification of DeduceTemplateArguments() and
//       getMoreSpecializedPartialSpecialization().
SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
Template->getPartialSpecializations(PartialSpecs);

for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
  VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
  TemplateDeductionInfo Info(FailedCandidates.getLocation());

  if (TemplateDeductionResult Result =
          DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
    // Store the failed-deduction information for use in diagnostics, later.
    // TODO: Actually use the failed-deduction info?
    FailedCandidates.addCandidate().set(
        DeclAccessPair::make(Template, AS_public), Partial,
        MakeDeductionFailureInfo(Context, Result, Info));
    (void)Result;
  } else {
    Matched.push_back(PartialSpecMatchResult());
    Matched.back().Partial = Partial;
    Matched.back().Args = Info.take();
  }
}

if (Matched.size() >= 1) {
  SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
  if (Matched.size() == 1) {
    //   -- If exactly one matching specialization is found, the
    //      instantiation is generated from that specialization.
    // We don't need to do anything for this.
  } else {
    //   -- If more than one matching specialization is found, the
    //      partial order rules (14.5.4.2) are used to determine
    //      whether one of the specializations is more specialized
    //      than the others. If none of the specializations is more
    //      specialized than all of the other matching
    //      specializations, then the use of the variable template is
    //      ambiguous and the program is ill-formed.
    for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
                                               PEnd = Matched.end();
         P != PEnd; ++P) {
      if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
                                                  PointOfInstantiation) ==
          P->Partial)
        Best = P;
    }

    // Determine if the best partial specialization is more specialized than
    // the others.
    for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
                                               PEnd = Matched.end();
         P != PEnd; ++P) {
      if (P != Best && getMoreSpecializedPartialSpecialization(
                           P->Partial, Best->Partial,
                           PointOfInstantiation) != Best->Partial) {
        AmbiguousPartialSpec = true;
        break;
      }
    }
  }

  // Instantiate using the best variable template partial specialization.
  InstantiationPattern = Best->Partial;
  InstantiationArgs = Best->Args;
} else {
  //   -- If no match is found, the instantiation is generated
  //      from the primary template.
  // InstantiationPattern = Template->getTemplatedDecl();
}

// 2. Create the canonical declaration.
// Note that we do not instantiate a definition until we see an odr-use
// in DoMarkVarDeclReferenced().
// FIXME: LateAttrs et al.?
VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
    Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
    Converted, TemplateNameLoc /*, LateAttrs, StartingScope*/);
if (!Decl)
  return true;

if (AmbiguousPartialSpec) {
  // Partial ordering did not produce a clear winner. Complain.
  Decl->setInvalidDecl();
  Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
      << Decl;

  // Print the matching partial specializations.
  for (MatchResult P : Matched)
    Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
        << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(),
                                           *P.Args);
  return true;
}

if (VarTemplatePartialSpecializationDecl *D =
        dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
  Decl->setInstantiationOf(D, InstantiationArgs);

checkSpecializationVisibility(TemplateNameLoc, Decl);

assert(Decl && "No variable template specialization?")((void)0);
return Decl;
4644}

4646ExprResult
4647Sema::CheckVarTemplateId(const CXXScopeSpec &SS,
                       const DeclarationNameInfo &NameInfo,
                       VarTemplateDecl *Template, SourceLocation TemplateLoc,
                       const TemplateArgumentListInfo *TemplateArgs) {

DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
                                     *TemplateArgs);
if (Decl.isInvalid())
  return ExprError();

if (!Decl.get())
  return ExprResult();

VarDecl *Var = cast<VarDecl>(Decl.get());
if (!Var->getTemplateSpecializationKind())
  Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation,
                                     NameInfo.getLoc());

// Build an ordinary singleton decl ref.
return BuildDeclarationNameExpr(SS, NameInfo, Var,
                                /*FoundD=*/nullptr, TemplateArgs);
4668}

4670void Sema::diagnoseMissingTemplateArguments(TemplateName Name,
                                          SourceLocation Loc) {
Diag(Loc, diag::err_template_missing_args)
  << (int)getTemplateNameKindForDiagnostics(Name) << Name;
if (TemplateDecl *TD = Name.getAsTemplateDecl()) {
  Diag(TD->getLocation(), diag::note_template_decl_here)
    << TD->getTemplateParameters()->getSourceRange();
}
4678}

4680ExprResult
4681Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
                           SourceLocation TemplateKWLoc,
                           const DeclarationNameInfo &ConceptNameInfo,
                           NamedDecl *FoundDecl,
                           ConceptDecl *NamedConcept,
                           const TemplateArgumentListInfo *TemplateArgs) {
assert(NamedConcept && "A concept template id without a template?")((void)0);

llvm::SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(NamedConcept, ConceptNameInfo.getLoc(),
64
←
Forming reference to null pointer
                         const_cast<TemplateArgumentListInfo&>(*TemplateArgs),
                              /*PartialTemplateArgs=*/false, Converted,
                              /*UpdateArgsWithConversion=*/false))
  return ExprError();

ConstraintSatisfaction Satisfaction;
bool AreArgsDependent =
    TemplateSpecializationType::anyDependentTemplateArguments(*TemplateArgs,
                                                              Converted);
if (!AreArgsDependent &&
    CheckConstraintSatisfaction(
        NamedConcept, {NamedConcept->getConstraintExpr()}, Converted,
        SourceRange(SS.isSet() ? SS.getBeginLoc() : ConceptNameInfo.getLoc(),
                    TemplateArgs->getRAngleLoc()),
        Satisfaction))
  return ExprError();

return ConceptSpecializationExpr::Create(Context,
    SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
    TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
    ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs), Converted,
    AreArgsDependent ? nullptr : &Satisfaction);
4713}

4715ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                   SourceLocation TemplateKWLoc,
                                   LookupResult &R,
                                   bool RequiresADL,
                               const TemplateArgumentListInfo *TemplateArgs) {
// FIXME: Can we do any checking at this point? I guess we could check the
// template arguments that we have against the template name, if the template
// name refers to a single template. That's not a terribly common case,
// though.
// foo<int> could identify a single function unambiguously
// This approach does NOT work, since f<int>(1);
// gets resolved prior to resorting to overload resolution
// i.e., template<class T> void f(double);
//       vs template<class T, class U> void f(U);

// These should be filtered out by our callers.
assert(!R.isAmbiguous() && "ambiguous lookup when building templateid")((void)0);

// Non-function templates require a template argument list.
if (auto *TD = R.getAsSingle<TemplateDecl>()) {
53
←
Assuming 'TD' is non-null→
54
←
Taking true branch→
  if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
55
←
Assuming 'TemplateArgs' is null→
56
←
Assuming 'TD' is a 'FunctionTemplateDecl'→
57
←
Taking false branch→
    diagnoseMissingTemplateArguments(TemplateName(TD), R.getNameLoc());
    return ExprError();
  }
}

// In C++1y, check variable template ids.
if (R.getAsSingle<VarTemplateDecl>()) {
58
←
Assuming the condition is false→
59
←
Taking false branch→
  ExprResult Res = CheckVarTemplateId(SS, R.getLookupNameInfo(),
                                      R.getAsSingle<VarTemplateDecl>(),
                                      TemplateKWLoc, TemplateArgs);
  if (Res.isInvalid() || Res.isUsable())
    return Res;
  // Result is dependent. Carry on to build an UnresolvedLookupEpxr.
}

if (R.getAsSingle<ConceptDecl>()) {
60
←
Assuming the condition is true→
61
←
Taking true branch→
  return CheckConceptTemplateId(SS, TemplateKWLoc, R.getLookupNameInfo(),
63
←
Calling 'Sema::CheckConceptTemplateId'→
                                R.getFoundDecl(),
                                R.getAsSingle<ConceptDecl>(), TemplateArgs);
62
←
Passing null pointer value via 6th parameter 'TemplateArgs'→
}

// We don't want lookup warnings at this point.
R.suppressDiagnostics();

UnresolvedLookupExpr *ULE
  = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
                                 SS.getWithLocInContext(Context),
                                 TemplateKWLoc,
                                 R.getLookupNameInfo(),
                                 RequiresADL, TemplateArgs,
                                 R.begin(), R.end());

return ULE;
4769}

4771// We actually only call this from template instantiation.
4772ExprResult
4773Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 const DeclarationNameInfo &NameInfo,
                           const TemplateArgumentListInfo *TemplateArgs) {

assert(TemplateArgs || TemplateKWLoc.isValid())((void)0);
DeclContext *DC;
if (!(DC = computeDeclContext(SS, false)) ||
1
Assuming pointer value is null→
2
←
Assuming 'DC' is non-null→
5
←
Taking false branch→
    DC->isDependentContext() ||
3
←
Assuming the condition is false→
    RequireCompleteDeclContext(SS, DC))
4
←
Assuming the condition is false→
  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);

bool MemberOfUnknownSpecialization;
LookupResult R(*this, NameInfo, LookupOrdinaryName);
if (LookupTemplateName(R, (Scope *)nullptr, SS, QualType(),
6
←
Calling 'Sema::LookupTemplateName'→
43
←
Returning from 'Sema::LookupTemplateName'→
44
←
Taking false branch→
                       /*Entering*/false, MemberOfUnknownSpecialization,
                       TemplateKWLoc))
  return ExprError();

if (R.isAmbiguous())
45
←
Assuming the condition is false→
46
←
Taking false branch→
  return ExprError();

if (R.empty()) {
47
←
Assuming the condition is false→
48
←
Taking false branch→
  Diag(NameInfo.getLoc(), diag::err_no_member)
    << NameInfo.getName() << DC << SS.getRange();
  return ExprError();
}

if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
49
←
Assuming 'Temp' is null→
50
←
Taking false branch→
  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
    << SS.getScopeRep()
    << NameInfo.getName().getAsString() << SS.getRange();
  Diag(Temp->getLocation(), diag::note_referenced_class_template);
  return ExprError();
}

return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
51
←
Passing value via 5th parameter 'TemplateArgs'→
52
←
Calling 'Sema::BuildTemplateIdExpr'→
4810}

4812/// Form a template name from a name that is syntactically required to name a
4813/// template, either due to use of the 'template' keyword or because a name in
4814/// this syntactic context is assumed to name a template (C++ [temp.names]p2-4).
4815///
4816/// This action forms a template name given the name of the template and its
4817/// optional scope specifier. This is used when the 'template' keyword is used
4818/// or when the parsing context unambiguously treats a following '<' as
4819/// introducing a template argument list. Note that this may produce a
4820/// non-dependent template name if we can perform the lookup now and identify
4821/// the named template.
4822///
4823/// For example, given "x.MetaFun::template apply", the scope specifier
4824/// \p SS will be "MetaFun::", \p TemplateKWLoc contains the location
4825/// of the "template" keyword, and "apply" is the \p Name.
4826TemplateNameKind Sema::ActOnTemplateName(Scope *S,
                                       CXXScopeSpec &SS,
                                       SourceLocation TemplateKWLoc,
                                       const UnqualifiedId &Name,
                                       ParsedType ObjectType,
                                       bool EnteringContext,
                                       TemplateTy &Result,
                                       bool AllowInjectedClassName) {
if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TemplateKWLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_template_outside_of_template :
         diag::ext_template_outside_of_template)
    << FixItHint::CreateRemoval(TemplateKWLoc);

if (SS.isInvalid())
  return TNK_Non_template;

// Figure out where isTemplateName is going to look.
DeclContext *LookupCtx = nullptr;
if (SS.isNotEmpty())
  LookupCtx = computeDeclContext(SS, EnteringContext);
else if (ObjectType)
  LookupCtx = computeDeclContext(GetTypeFromParser(ObjectType));

// C++0x [temp.names]p5:
//   If a name prefixed by the keyword template is not the name of
//   a template, the program is ill-formed. [Note: the keyword
//   template may not be applied to non-template members of class
//   templates. -end note ] [ Note: as is the case with the
//   typename prefix, the template prefix is allowed in cases
//   where it is not strictly necessary; i.e., when the
//   nested-name-specifier or the expression on the left of the ->
//   or . is not dependent on a template-parameter, or the use
//   does not appear in the scope of a template. -end note]
//
// Note: C++03 was more strict here, because it banned the use of
// the "template" keyword prior to a template-name that was not a
// dependent name. C++ DR468 relaxed this requirement (the
// "template" keyword is now permitted). We follow the C++0x
// rules, even in C++03 mode with a warning, retroactively applying the DR.
bool MemberOfUnknownSpecialization;
TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
                                      ObjectType, EnteringContext, Result,
                                      MemberOfUnknownSpecialization);
if (TNK != TNK_Non_template) {
  // We resolved this to a (non-dependent) template name. Return it.
  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
  if (!AllowInjectedClassName && SS.isNotEmpty() && LookupRD &&
      Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
      Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
    // C++14 [class.qual]p2:
    //   In a lookup in which function names are not ignored and the
    //   nested-name-specifier nominates a class C, if the name specified
    //   [...] is the injected-class-name of C, [...] the name is instead
    //   considered to name the constructor
    //
    // We don't get here if naming the constructor would be valid, so we
    // just reject immediately and recover by treating the
    // injected-class-name as naming the template.
    Diag(Name.getBeginLoc(),
         diag::ext_out_of_line_qualified_id_type_names_constructor)
        << Name.Identifier
        << 0 /*injected-class-name used as template name*/
        << TemplateKWLoc.isValid();
  }
  return TNK;
}

if (!MemberOfUnknownSpecialization) {
  // Didn't find a template name, and the lookup wasn't dependent.
  // Do the lookup again to determine if this is a "nothing found" case or
  // a "not a template" case. FIXME: Refactor isTemplateName so we don't
  // need to do this.
  DeclarationNameInfo DNI = GetNameFromUnqualifiedId(Name);
  LookupResult R(*this, DNI.getName(), Name.getBeginLoc(),
                 LookupOrdinaryName);
  bool MOUS;
  // Tell LookupTemplateName that we require a template so that it diagnoses
  // cases where it finds a non-template.
  RequiredTemplateKind RTK = TemplateKWLoc.isValid()
                                 ? RequiredTemplateKind(TemplateKWLoc)
                                 : TemplateNameIsRequired;
  if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext, MOUS,
                          RTK, nullptr, /*AllowTypoCorrection=*/false) &&
      !R.isAmbiguous()) {
    if (LookupCtx)
      Diag(Name.getBeginLoc(), diag::err_no_member)
          << DNI.getName() << LookupCtx << SS.getRange();
    else
      Diag(Name.getBeginLoc(), diag::err_undeclared_use)
          << DNI.getName() << SS.getRange();
  }
  return TNK_Non_template;
}

NestedNameSpecifier *Qualifier = SS.getScopeRep();

switch (Name.getKind()) {
case UnqualifiedIdKind::IK_Identifier:
  Result = TemplateTy::make(
      Context.getDependentTemplateName(Qualifier, Name.Identifier));
  return TNK_Dependent_template_name;

case UnqualifiedIdKind::IK_OperatorFunctionId:
  Result = TemplateTy::make(Context.getDependentTemplateName(
      Qualifier, Name.OperatorFunctionId.Operator));
  return TNK_Function_template;

case UnqualifiedIdKind::IK_LiteralOperatorId:
  // This is a kind of template name, but can never occur in a dependent
  // scope (literal operators can only be declared at namespace scope).
  break;

default:
  break;
}

// This name cannot possibly name a dependent template. Diagnose this now
// rather than building a dependent template name that can never be valid.
Diag(Name.getBeginLoc(),
     diag::err_template_kw_refers_to_dependent_non_template)
    << GetNameFromUnqualifiedId(Name).getName() << Name.getSourceRange()
    << TemplateKWLoc.isValid() << TemplateKWLoc;
return TNK_Non_template;
4951}

4953bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
                                   TemplateArgumentLoc &AL,
                        SmallVectorImpl<TemplateArgument> &Converted) {
const TemplateArgument &Arg = AL.getArgument();
QualType ArgType;
TypeSourceInfo *TSI = nullptr;

// Check template type parameter.
switch(Arg.getKind()) {
case TemplateArgument::Type:
  // C++ [temp.arg.type]p1:
  //   A template-argument for a template-parameter which is a
  //   type shall be a type-id.
  ArgType = Arg.getAsType();
  TSI = AL.getTypeSourceInfo();
  break;
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion: {
  // We have a template type parameter but the template argument
  // is a template without any arguments.
  SourceRange SR = AL.getSourceRange();
  TemplateName Name = Arg.getAsTemplateOrTemplatePattern();
  diagnoseMissingTemplateArguments(Name, SR.getEnd());
  return true;
}
case TemplateArgument::Expression: {
  // We have a template type parameter but the template argument is an
  // expression; see if maybe it is missing the "typename" keyword.
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo;

 if (DependentScopeDeclRefExpr *ArgExpr =
             dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
    SS.Adopt(ArgExpr->getQualifierLoc());
    NameInfo = ArgExpr->getNameInfo();
  } else if (CXXDependentScopeMemberExpr *ArgExpr =
             dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
    if (ArgExpr->isImplicitAccess()) {
      SS.Adopt(ArgExpr->getQualifierLoc());
      NameInfo = ArgExpr->getMemberNameInfo();
    }
  }

  if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
    LookupResult Result(*this, NameInfo, LookupOrdinaryName);
    LookupParsedName(Result, CurScope, &SS);

    if (Result.getAsSingle<TypeDecl>() ||
        Result.getResultKind() ==
            LookupResult::NotFoundInCurrentInstantiation) {
      assert(SS.getScopeRep() && "dependent scope expr must has a scope!")((void)0);
      // Suggest that the user add 'typename' before the NNS.
      SourceLocation Loc = AL.getSourceRange().getBegin();
      Diag(Loc, getLangOpts().MSVCCompat
                    ? diag::ext_ms_template_type_arg_missing_typename
                    : diag::err_template_arg_must_be_type_suggest)
          << FixItHint::CreateInsertion(Loc, "typename ");
      Diag(Param->getLocation(), diag::note_template_param_here);

      // Recover by synthesizing a type using the location information that we
      // already have.
      ArgType =
          Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), II);
      TypeLocBuilder TLB;
      DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
      TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
      TL.setQualifierLoc(SS.getWithLocInContext(Context));
      TL.setNameLoc(NameInfo.getLoc());
      TSI = TLB.getTypeSourceInfo(Context, ArgType);

      // Overwrite our input TemplateArgumentLoc so that we can recover
      // properly.
      AL = TemplateArgumentLoc(TemplateArgument(ArgType),
                               TemplateArgumentLocInfo(TSI));

      break;
    }
  }
  // fallthrough
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
}
default: {
  // We have a template type parameter but the template argument
  // is not a type.
  SourceRange SR = AL.getSourceRange();
  Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
  Diag(Param->getLocation(), diag::note_template_param_here);

  return true;
}
}

if (CheckTemplateArgument(TSI))
  return true;

// Add the converted template type argument.
ArgType = Context.getCanonicalType(ArgType);

// Objective-C ARC:
//   If an explicitly-specified template argument type is a lifetime type
//   with no lifetime qualifier, the __strong lifetime qualifier is inferred.
if (getLangOpts().ObjCAutoRefCount &&
    ArgType->isObjCLifetimeType() &&
    !ArgType.getObjCLifetime()) {
  Qualifiers Qs;
  Qs.setObjCLifetime(Qualifiers::OCL_Strong);
  ArgType = Context.getQualifiedType(ArgType, Qs);
}

Converted.push_back(TemplateArgument(ArgType));
return false;
5064}

5066/// Substitute template arguments into the default template argument for
5067/// the given template type parameter.
5068///
5069/// \param SemaRef the semantic analysis object for which we are performing
5070/// the substitution.
5071///
5072/// \param Template the template that we are synthesizing template arguments
5073/// for.
5074///
5075/// \param TemplateLoc the location of the template name that started the
5076/// template-id we are checking.
5077///
5078/// \param RAngleLoc the location of the right angle bracket ('>') that
5079/// terminates the template-id.
5080///
5081/// \param Param the template template parameter whose default we are
5082/// substituting into.
5083///
5084/// \param Converted the list of template arguments provided for template
5085/// parameters that precede \p Param in the template parameter list.
5086/// \returns the substituted template argument, or NULL if an error occurred.
5087static TypeSourceInfo *
5088SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           TemplateTypeParmDecl *Param,
                           SmallVectorImpl<TemplateArgument> &Converted) {
TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();

// If the argument type is dependent, instantiate it now based
// on the previously-computed template arguments.
if (ArgType->getType()->isInstantiationDependentType()) {
  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
                                   Param, Template, Converted,
                                   SourceRange(TemplateLoc, RAngleLoc));
  if (Inst.isInvalid())
    return nullptr;

  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

  // Only substitute for the innermost template argument list.
  MultiLevelTemplateArgumentList TemplateArgLists;
  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
    TemplateArgLists.addOuterTemplateArguments(None);

  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
  ArgType =
      SemaRef.SubstType(ArgType, TemplateArgLists,
                        Param->getDefaultArgumentLoc(), Param->getDeclName());
}

return ArgType;
5120}

5122/// Substitute template arguments into the default template argument for
5123/// the given non-type template parameter.
5124///
5125/// \param SemaRef the semantic analysis object for which we are performing
5126/// the substitution.
5127///
5128/// \param Template the template that we are synthesizing template arguments
5129/// for.
5130///
5131/// \param TemplateLoc the location of the template name that started the
5132/// template-id we are checking.
5133///
5134/// \param RAngleLoc the location of the right angle bracket ('>') that
5135/// terminates the template-id.
5136///
5137/// \param Param the non-type template parameter whose default we are
5138/// substituting into.
5139///
5140/// \param Converted the list of template arguments provided for template
5141/// parameters that precede \p Param in the template parameter list.
5142///
5143/// \returns the substituted template argument, or NULL if an error occurred.
5144static ExprResult
5145SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           NonTypeTemplateParmDecl *Param,
                      SmallVectorImpl<TemplateArgument> &Converted) {
Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
                                 Param, Template, Converted,
                                 SourceRange(TemplateLoc, RAngleLoc));
if (Inst.isInvalid())
  return ExprError();

TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

// Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
  TemplateArgLists.addOuterTemplateArguments(None);

Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
EnterExpressionEvaluationContext ConstantEvaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
5169}

5171/// Substitute template arguments into the default template argument for
5172/// the given template template parameter.
5173///
5174/// \param SemaRef the semantic analysis object for which we are performing
5175/// the substitution.
5176///
5177/// \param Template the template that we are synthesizing template arguments
5178/// for.
5179///
5180/// \param TemplateLoc the location of the template name that started the
5181/// template-id we are checking.
5182///
5183/// \param RAngleLoc the location of the right angle bracket ('>') that
5184/// terminates the template-id.
5185///
5186/// \param Param the template template parameter whose default we are
5187/// substituting into.
5188///
5189/// \param Converted the list of template arguments provided for template
5190/// parameters that precede \p Param in the template parameter list.
5191///
5192/// \param QualifierLoc Will be set to the nested-name-specifier (with
5193/// source-location information) that precedes the template name.
5194///
5195/// \returns the substituted template argument, or NULL if an error occurred.
5196static TemplateName
5197SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           TemplateTemplateParmDecl *Param,
                     SmallVectorImpl<TemplateArgument> &Converted,
                           NestedNameSpecifierLoc &QualifierLoc) {
Sema::InstantiatingTemplate Inst(
    SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
    SourceRange(TemplateLoc, RAngleLoc));
if (Inst.isInvalid())
  return TemplateName();

TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

// Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
  TemplateArgLists.addOuterTemplateArguments(None);

Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
// Substitute into the nested-name-specifier first,
QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
if (QualifierLoc) {
  QualifierLoc =
      SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
  if (!QualifierLoc)
    return TemplateName();
}

return SemaRef.SubstTemplateName(
           QualifierLoc,
           Param->getDefaultArgument().getArgument().getAsTemplate(),
           Param->getDefaultArgument().getTemplateNameLoc(),
           TemplateArgLists);
5233}

5235/// If the given template parameter has a default template
5236/// argument, substitute into that default template argument and
5237/// return the corresponding template argument.
5238TemplateArgumentLoc
5239Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
                                            SourceLocation TemplateLoc,
                                            SourceLocation RAngleLoc,
                                            Decl *Param,
                                            SmallVectorImpl<TemplateArgument>
                                              &Converted,
                                            bool &HasDefaultArg) {
HasDefaultArg = false;

if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
  if (!hasVisibleDefaultArgument(TypeParm))
    return TemplateArgumentLoc();

  HasDefaultArg = true;
  TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
                                                    TemplateLoc,
                                                    RAngleLoc,
                                                    TypeParm,
                                                    Converted);
  if (DI)
    return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);

  return TemplateArgumentLoc();
}

if (NonTypeTemplateParmDecl *NonTypeParm
      = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  if (!hasVisibleDefaultArgument(NonTypeParm))
    return TemplateArgumentLoc();

  HasDefaultArg = true;
  ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
                                                TemplateLoc,
                                                RAngleLoc,
                                                NonTypeParm,
                                                Converted);
  if (Arg.isInvalid())
    return TemplateArgumentLoc();

  Expr *ArgE = Arg.getAs<Expr>();
  return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
}

TemplateTemplateParmDecl *TempTempParm
  = cast<TemplateTemplateParmDecl>(Param);
if (!hasVisibleDefaultArgument(TempTempParm))
  return TemplateArgumentLoc();

HasDefaultArg = true;
NestedNameSpecifierLoc QualifierLoc;
TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
                                                  TemplateLoc,
                                                  RAngleLoc,
                                                  TempTempParm,
                                                  Converted,
                                                  QualifierLoc);
if (TName.isNull())
  return TemplateArgumentLoc();

return TemplateArgumentLoc(
    Context, TemplateArgument(TName),
    TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
    TempTempParm->getDefaultArgument().getTemplateNameLoc());
5302}

5304/// Convert a template-argument that we parsed as a type into a template, if
5305/// possible. C++ permits injected-class-names to perform dual service as
5306/// template template arguments and as template type arguments.
5307static TemplateArgumentLoc
5308convertTypeTemplateArgumentToTemplate(ASTContext &Context, TypeLoc TLoc) {
// Extract and step over any surrounding nested-name-specifier.
NestedNameSpecifierLoc QualLoc;
if (auto ETLoc = TLoc.getAs<ElaboratedTypeLoc>()) {
  if (ETLoc.getTypePtr()->getKeyword() != ETK_None)
    return TemplateArgumentLoc();

  QualLoc = ETLoc.getQualifierLoc();
  TLoc = ETLoc.getNamedTypeLoc();
}
// If this type was written as an injected-class-name, it can be used as a
// template template argument.
if (auto InjLoc = TLoc.getAs<InjectedClassNameTypeLoc>())
  return TemplateArgumentLoc(Context, InjLoc.getTypePtr()->getTemplateName(),
                             QualLoc, InjLoc.getNameLoc());

// If this type was written as an injected-class-name, it may have been
// converted to a RecordType during instantiation. If the RecordType is
// *not* wrapped in a TemplateSpecializationType and denotes a class
// template specialization, it must have come from an injected-class-name.
if (auto RecLoc = TLoc.getAs<RecordTypeLoc>())
  if (auto *CTSD =
          dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
    return TemplateArgumentLoc(Context,
                               TemplateName(CTSD->getSpecializedTemplate()),
                               QualLoc, RecLoc.getNameLoc());

return TemplateArgumentLoc();
5336}

5338/// Check that the given template argument corresponds to the given
5339/// template parameter.
5340///
5341/// \param Param The template parameter against which the argument will be
5342/// checked.
5343///
5344/// \param Arg The template argument, which may be updated due to conversions.
5345///
5346/// \param Template The template in which the template argument resides.
5347///
5348/// \param TemplateLoc The location of the template name for the template
5349/// whose argument list we're matching.
5350///
5351/// \param RAngleLoc The location of the right angle bracket ('>') that closes
5352/// the template argument list.
5353///
5354/// \param ArgumentPackIndex The index into the argument pack where this
5355/// argument will be placed. Only valid if the parameter is a parameter pack.
5356///
5357/// \param Converted The checked, converted argument will be added to the
5358/// end of this small vector.
5359///
5360/// \param CTAK Describes how we arrived at this particular template argument:
5361/// explicitly written, deduced, etc.
5362///
5363/// \returns true on error, false otherwise.
5364bool Sema::CheckTemplateArgument(NamedDecl *Param,
                               TemplateArgumentLoc &Arg,
                               NamedDecl *Template,
                               SourceLocation TemplateLoc,
                               SourceLocation RAngleLoc,
                               unsigned ArgumentPackIndex,
                          SmallVectorImpl<TemplateArgument> &Converted,
                               CheckTemplateArgumentKind CTAK) {
// Check template type parameters.
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
  return CheckTemplateTypeArgument(TTP, Arg, Converted);

// Check non-type template parameters.
if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  // Do substitution on the type of the non-type template parameter
  // with the template arguments we've seen thus far.  But if the
  // template has a dependent context then we cannot substitute yet.
  QualType NTTPType = NTTP->getType();
  if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
    NTTPType = NTTP->getExpansionType(ArgumentPackIndex);

  if (NTTPType->isInstantiationDependentType() &&
      !isa<TemplateTemplateParmDecl>(Template) &&
      !Template->getDeclContext()->isDependentContext()) {
    // Do substitution on the type of the non-type template parameter.
    InstantiatingTemplate Inst(*this, TemplateLoc, Template,
                               NTTP, Converted,
                               SourceRange(TemplateLoc, RAngleLoc));
    if (Inst.isInvalid())
      return true;

    TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
                                      Converted);

    // If the parameter is a pack expansion, expand this slice of the pack.
    if (auto *PET = NTTPType->getAs<PackExpansionType>()) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this,
                                                         ArgumentPackIndex);
      NTTPType = SubstType(PET->getPattern(),
                           MultiLevelTemplateArgumentList(TemplateArgs),
                           NTTP->getLocation(),
                           NTTP->getDeclName());
    } else {
      NTTPType = SubstType(NTTPType,
                           MultiLevelTemplateArgumentList(TemplateArgs),
                           NTTP->getLocation(),
                           NTTP->getDeclName());
    }

    // If that worked, check the non-type template parameter type
    // for validity.
    if (!NTTPType.isNull())
      NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
                                                   NTTP->getLocation());
    if (NTTPType.isNull())
      return true;
  }

  switch (Arg.getArgument().getKind()) {
  case TemplateArgument::Null:
    llvm_unreachable("Should never see a NULL template argument here")__builtin_unreachable();

  case TemplateArgument::Expression: {
    TemplateArgument Result;
    unsigned CurSFINAEErrors = NumSFINAEErrors;
    ExprResult Res =
      CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
                            Result, CTAK);
    if (Res.isInvalid())
      return true;
    // If the current template argument causes an error, give up now.
    if (CurSFINAEErrors < NumSFINAEErrors)
      return true;

    // If the resulting expression is new, then use it in place of the
    // old expression in the template argument.
    if (Res.get() != Arg.getArgument().getAsExpr()) {
      TemplateArgument TA(Res.get());
      Arg = TemplateArgumentLoc(TA, Res.get());
    }

    Converted.push_back(Result);
    break;
  }

  case TemplateArgument::Declaration:
  case TemplateArgument::Integral:
  case TemplateArgument::NullPtr:
    // We've already checked this template argument, so just copy
    // it to the list of converted arguments.
    Converted.push_back(Arg.getArgument());
    break;

  case TemplateArgument::Template:
  case TemplateArgument::TemplateExpansion:
    // We were given a template template argument. It may not be ill-formed;
    // see below.
    if (DependentTemplateName *DTN
          = Arg.getArgument().getAsTemplateOrTemplatePattern()
                                            .getAsDependentTemplateName()) {
      // We have a template argument such as \c T::template X, which we
      // parsed as a template template argument. However, since we now
      // know that we need a non-type template argument, convert this
      // template name into an expression.

      DeclarationNameInfo NameInfo(DTN->getIdentifier(),
                                   Arg.getTemplateNameLoc());

      CXXScopeSpec SS;
      SS.Adopt(Arg.getTemplateQualifierLoc());
      // FIXME: the template-template arg was a DependentTemplateName,
      // so it was provided with a template keyword. However, its source
      // location is not stored in the template argument structure.
      SourceLocation TemplateKWLoc;
      ExprResult E = DependentScopeDeclRefExpr::Create(
          Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
          nullptr);

      // If we parsed the template argument as a pack expansion, create a
      // pack expansion expression.
      if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
        E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
        if (E.isInvalid())
          return true;
      }

      TemplateArgument Result;
      E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
      if (E.isInvalid())
        return true;

      Converted.push_back(Result);
      break;
    }

    // We have a template argument that actually does refer to a class
    // template, alias template, or template template parameter, and
    // therefore cannot be a non-type template argument.
    Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
      << Arg.getSourceRange();

    Diag(Param->getLocation(), diag::note_template_param_here);
    return true;

  case TemplateArgument::Type: {
    // We have a non-type template parameter but the template
    // argument is a type.

    // C++ [temp.arg]p2:
    //   In a template-argument, an ambiguity between a type-id and
    //   an expression is resolved to a type-id, regardless of the
    //   form of the corresponding template-parameter.
    //
    // We warn specifically about this case, since it can be rather
    // confusing for users.
    QualType T = Arg.getArgument().getAsType();
    SourceRange SR = Arg.getSourceRange();
    if (T->isFunctionType())
      Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
    else
      Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
    Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }

  case TemplateArgument::Pack:
    llvm_unreachable("Caller must expand template argument packs")__builtin_unreachable();
  }

  return false;
}


// Check template template parameters.
TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);

TemplateParameterList *Params = TempParm->getTemplateParameters();
if (TempParm->isExpandedParameterPack())
  Params = TempParm->getExpansionTemplateParameters(ArgumentPackIndex);

// Substitute into the template parameter list of the template
// template parameter, since previously-supplied template arguments
// may appear within the template template parameter.
//
// FIXME: Skip this if the parameters aren't instantiation-dependent.
{
  // Set up a template instantiation context.
  LocalInstantiationScope Scope(*this);
  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
                             TempParm, Converted,
                             SourceRange(TemplateLoc, RAngleLoc));
  if (Inst.isInvalid())
    return true;

  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
  Params = SubstTemplateParams(Params, CurContext,
                               MultiLevelTemplateArgumentList(TemplateArgs));
  if (!Params)
    return true;
}

// C++1z [temp.local]p1: (DR1004)
//   When [the injected-class-name] is used [...] as a template-argument for
//   a template template-parameter [...] it refers to the class template
//   itself.
if (Arg.getArgument().getKind() == TemplateArgument::Type) {
  TemplateArgumentLoc ConvertedArg = convertTypeTemplateArgumentToTemplate(
      Context, Arg.getTypeSourceInfo()->getTypeLoc());
  if (!ConvertedArg.getArgument().isNull())
    Arg = ConvertedArg;
}

switch (Arg.getArgument().getKind()) {
case TemplateArgument::Null:
  llvm_unreachable("Should never see a NULL template argument here")__builtin_unreachable();

case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
  if (CheckTemplateTemplateArgument(TempParm, Params, Arg))
    return true;

  Converted.push_back(Arg.getArgument());
  break;

case TemplateArgument::Expression:
case TemplateArgument::Type:
  // We have a template template parameter but the template
  // argument does not refer to a template.
  Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
    << getLangOpts().CPlusPlus11;
  return true;

case TemplateArgument::Declaration:
  llvm_unreachable("Declaration argument with template template parameter")__builtin_unreachable();
case TemplateArgument::Integral:
  llvm_unreachable("Integral argument with template template parameter")__builtin_unreachable();
case TemplateArgument::NullPtr:
  llvm_unreachable("Null pointer argument with template template parameter")__builtin_unreachable();

case TemplateArgument::Pack:
  llvm_unreachable("Caller must expand template argument packs")__builtin_unreachable();
}

return false;
5608}

5610/// Diagnose a missing template argument.
5611template<typename TemplateParmDecl>
5612static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
                                  TemplateDecl *TD,
                                  const TemplateParmDecl *D,
                                  TemplateArgumentListInfo &Args) {
// Dig out the most recent declaration of the template parameter; there may be
// declarations of the template that are more recent than TD.
D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
                               ->getTemplateParameters()
                               ->getParam(D->getIndex()));

// If there's a default argument that's not visible, diagnose that we're
// missing a module import.
llvm::SmallVector<Module*, 8> Modules;
if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
  S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
                          D->getDefaultArgumentLoc(), Modules,
                          Sema::MissingImportKind::DefaultArgument,
                          /*Recover*/true);
  return true;
}

// FIXME: If there's a more recent default argument that *is* visible,
// diagnose that it was declared too late.

TemplateParameterList *Params = TD->getTemplateParameters();

S.Diag(Loc, diag::err_template_arg_list_different_arity)
  << /*not enough args*/0
  << (int)S.getTemplateNameKindForDiagnostics(TemplateName(TD))
  << TD;
S.Diag(TD->getLocation(), diag::note_template_decl_here)
  << Params->getSourceRange();
return true;
5645}

5647/// Check that the given template argument list is well-formed
5648/// for specializing the given template.
5649bool Sema::CheckTemplateArgumentList(
  TemplateDecl *Template, SourceLocation TemplateLoc,
  TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
  SmallVectorImpl<TemplateArgument> &Converted,
  bool UpdateArgsWithConversions, bool *ConstraintsNotSatisfied) {

if (ConstraintsNotSatisfied)
  *ConstraintsNotSatisfied = false;

// Make a copy of the template arguments for processing.  Only make the
// changes at the end when successful in matching the arguments to the
// template.
TemplateArgumentListInfo NewArgs = TemplateArgs;

// Make sure we get the template parameter list from the most
// recent declaration, since that is the only one that is guaranteed to
// have all the default template argument information.
TemplateParameterList *Params =
    cast<TemplateDecl>(Template->getMostRecentDecl())
        ->getTemplateParameters();

SourceLocation RAngleLoc = NewArgs.getRAngleLoc();

// C++ [temp.arg]p1:
//   [...] The type and form of each template-argument specified in
//   a template-id shall match the type and form specified for the
//   corresponding parameter declared by the template in its
//   template-parameter-list.
bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
SmallVector<TemplateArgument, 2> ArgumentPack;
unsigned ArgIdx = 0, NumArgs = NewArgs.size();
LocalInstantiationScope InstScope(*this, true);
for (TemplateParameterList::iterator Param = Params->begin(),
                                     ParamEnd = Params->end();
     Param != ParamEnd; /* increment in loop */) {
  // If we have an expanded parameter pack, make sure we don't have too
  // many arguments.
  if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
    if (*Expansions == ArgumentPack.size()) {
      // We're done with this parameter pack. Pack up its arguments and add
      // them to the list.
      Converted.push_back(
          TemplateArgument::CreatePackCopy(Context, ArgumentPack));
      ArgumentPack.clear();

      // This argument is assigned to the next parameter.
      ++Param;
      continue;
    } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
      // Not enough arguments for this parameter pack.
      Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
        << /*not enough args*/0
        << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
        << Template;
      Diag(Template->getLocation(), diag::note_template_decl_here)
        << Params->getSourceRange();
      return true;
    }
  }

  if (ArgIdx < NumArgs) {
    // Check the template argument we were given.
    if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
                              TemplateLoc, RAngleLoc,
                              ArgumentPack.size(), Converted))
      return true;

    bool PackExpansionIntoNonPack =
        NewArgs[ArgIdx].getArgument().isPackExpansion() &&
        (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
    if (PackExpansionIntoNonPack && (isa<TypeAliasTemplateDecl>(Template) ||
                                     isa<ConceptDecl>(Template))) {
      // Core issue 1430: we have a pack expansion as an argument to an
      // alias template, and it's not part of a parameter pack. This
      // can't be canonicalized, so reject it now.
      // As for concepts - we cannot normalize constraints where this
      // situation exists.
      Diag(NewArgs[ArgIdx].getLocation(),
           diag::err_template_expansion_into_fixed_list)
        << (isa<ConceptDecl>(Template) ? 1 : 0)
        << NewArgs[ArgIdx].getSourceRange();
      Diag((*Param)->getLocation(), diag::note_template_param_here);
      return true;
    }

    // We're now done with this argument.
    ++ArgIdx;

    if ((*Param)->isTemplateParameterPack()) {
      // The template parameter was a template parameter pack, so take the
      // deduced argument and place it on the argument pack. Note that we
      // stay on the same template parameter so that we can deduce more
      // arguments.
      ArgumentPack.push_back(Converted.pop_back_val());
    } else {
      // Move to the next template parameter.
      ++Param;
    }

    // If we just saw a pack expansion into a non-pack, then directly convert
    // the remaining arguments, because we don't know what parameters they'll
    // match up with.
    if (PackExpansionIntoNonPack) {
      if (!ArgumentPack.empty()) {
        // If we were part way through filling in an expanded parameter pack,
        // fall back to just producing individual arguments.
        Converted.insert(Converted.end(),
                         ArgumentPack.begin(), ArgumentPack.end());
        ArgumentPack.clear();
      }

      while (ArgIdx < NumArgs) {
        Converted.push_back(NewArgs[ArgIdx].getArgument());
        ++ArgIdx;
      }

      return false;
    }

    continue;
  }

  // If we're checking a partial template argument list, we're done.
  if (PartialTemplateArgs) {
    if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
      Converted.push_back(
          TemplateArgument::CreatePackCopy(Context, ArgumentPack));
    return false;
  }

  // If we have a template parameter pack with no more corresponding
  // arguments, just break out now and we'll fill in the argument pack below.
  if ((*Param)->isTemplateParameterPack()) {
    assert(!getExpandedPackSize(*Param) &&((void)0)
           "Should have dealt with this already")((void)0);

    // A non-expanded parameter pack before the end of the parameter list
    // only occurs for an ill-formed template parameter list, unless we've
    // got a partial argument list for a function template, so just bail out.
    if (Param + 1 != ParamEnd)
      return true;

    Converted.push_back(
        TemplateArgument::CreatePackCopy(Context, ArgumentPack));
    ArgumentPack.clear();

    ++Param;
    continue;
  }

  // Check whether we have a default argument.
  TemplateArgumentLoc Arg;

  // Retrieve the default template argument from the template
  // parameter. For each kind of template parameter, we substitute the
  // template arguments provided thus far and any "outer" template arguments
  // (when the template parameter was part of a nested template) into
  // the default argument.
  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
    if (!hasVisibleDefaultArgument(TTP))
      return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
                                     NewArgs);

    TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
                                                           Template,
                                                           TemplateLoc,
                                                           RAngleLoc,
                                                           TTP,
                                                           Converted);
    if (!ArgType)
      return true;

    Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
                              ArgType);
  } else if (NonTypeTemplateParmDecl *NTTP
               = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
    if (!hasVisibleDefaultArgument(NTTP))
      return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
                                     NewArgs);

    ExprResult E = SubstDefaultTemplateArgument(*this, Template,
                                                            TemplateLoc,
                                                            RAngleLoc,
                                                            NTTP,
                                                            Converted);
    if (E.isInvalid())
      return true;

    Expr *Ex = E.getAs<Expr>();
    Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
  } else {
    TemplateTemplateParmDecl *TempParm
      = cast<TemplateTemplateParmDecl>(*Param);

    if (!hasVisibleDefaultArgument(TempParm))
      return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
                                     NewArgs);

    NestedNameSpecifierLoc QualifierLoc;
    TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
                                                     TemplateLoc,
                                                     RAngleLoc,
                                                     TempParm,
                                                     Converted,
                                                     QualifierLoc);
    if (Name.isNull())
      return true;

    Arg = TemplateArgumentLoc(
        Context, TemplateArgument(Name), QualifierLoc,
        TempParm->getDefaultArgument().getTemplateNameLoc());
  }

  // Introduce an instantiation record that describes where we are using
  // the default template argument. We're not actually instantiating a
  // template here, we just create this object to put a note into the
  // context stack.
  InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
                             SourceRange(TemplateLoc, RAngleLoc));
  if (Inst.isInvalid())
    return true;

  // Check the default template argument.
  if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
                            RAngleLoc, 0, Converted))
    return true;

  // Core issue 150 (assumed resolution): if this is a template template
  // parameter, keep track of the default template arguments from the
  // template definition.
  if (isTemplateTemplateParameter)
    NewArgs.addArgument(Arg);

  // Move to the next template parameter and argument.
  ++Param;
  ++ArgIdx;
}

// If we're performing a partial argument substitution, allow any trailing
// pack expansions; they might be empty. This can happen even if
// PartialTemplateArgs is false (the list of arguments is complete but
// still dependent).
if (ArgIdx < NumArgs && CurrentInstantiationScope &&
    CurrentInstantiationScope->getPartiallySubstitutedPack()) {
  while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
    Converted.push_back(NewArgs[ArgIdx++].getArgument());
}

// If we have any leftover arguments, then there were too many arguments.
// Complain and fail.
if (ArgIdx < NumArgs) {
  Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
      << /*too many args*/1
      << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
      << Template
      << SourceRange(NewArgs[ArgIdx].getLocation(), NewArgs.getRAngleLoc());
  Diag(Template->getLocation(), diag::note_template_decl_here)
      << Params->getSourceRange();
  return true;
}

// No problems found with the new argument list, propagate changes back
// to caller.
if (UpdateArgsWithConversions)
  TemplateArgs = std::move(NewArgs);

if (!PartialTemplateArgs &&
    EnsureTemplateArgumentListConstraints(
      Template, Converted, SourceRange(TemplateLoc,
                                       TemplateArgs.getRAngleLoc()))) {
  if (ConstraintsNotSatisfied)
    *ConstraintsNotSatisfied = true;
  return true;
}

return false;
5925}

5927namespace {
class UnnamedLocalNoLinkageFinder
  : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
{
  Sema &S;
  SourceRange SR;

  typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited;

public:
  UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }

  bool Visit(QualType T) {
    return T.isNull() ? false : inherited::Visit(T.getTypePtr());
  }

5943#define TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *);
5945#define ABSTRACT_TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *) { return false; }
5947#define NON_CANONICAL_TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *) { return false; }
5949#include "clang/AST/TypeNodes.inc"

  bool VisitTagDecl(const TagDecl *Tag);
  bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
};
5954} // end anonymous namespace

5956bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
return false;
5958}

5960bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
return Visit(T->getElementType());
5962}

5964bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
return Visit(T->getPointeeType());
5966}

5968bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
                                                  const BlockPointerType* T) {
return Visit(T->getPointeeType());
5971}

5973bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
                                              const LValueReferenceType* T) {
return Visit(T->getPointeeType());
5976}

5978bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
                                              const RValueReferenceType* T) {
return Visit(T->getPointeeType());
5981}

5983bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
                                                const MemberPointerType* T) {
return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
5986}

5988bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
                                                const ConstantArrayType* T) {
return Visit(T->getElementType());
5991}

5993bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
                                               const IncompleteArrayType* T) {
return Visit(T->getElementType());
5996}

5998bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
                                                 const VariableArrayType* T) {
return Visit(T->getElementType());
6001}

6003bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
                                          const DependentSizedArrayType* T) {
return Visit(T->getElementType());
6006}

6008bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
                                       const DependentSizedExtVectorType* T) {
return Visit(T->getElementType());
6011}

6013bool UnnamedLocalNoLinkageFinder::VisitDependentSizedMatrixType(
  const DependentSizedMatrixType *T) {
return Visit(T->getElementType());
6016}

6018bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
  const DependentAddressSpaceType *T) {
return Visit(T->getPointeeType());
6021}

6023bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
return Visit(T->getElementType());
6025}

6027bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
  const DependentVectorType *T) {
return Visit(T->getElementType());
6030}

6032bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
return Visit(T->getElementType());
6034}

6036bool UnnamedLocalNoLinkageFinder::VisitConstantMatrixType(
  const ConstantMatrixType *T) {
return Visit(T->getElementType());
6039}

6041bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
                                                const FunctionProtoType* T) {
for (const auto &A : T->param_types()) {
  if (Visit(A))
    return true;
}

return Visit(T->getReturnType());
6049}

6051bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
                                             const FunctionNoProtoType* T) {
return Visit(T->getReturnType());
6054}

6056bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
                                                const UnresolvedUsingType*) {
return false;
6059}

6061bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
return false;
6063}

6065bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
return Visit(T->getUnderlyingType());
6067}

6069bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
return false;
6071}

6073bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
                                                  const UnaryTransformType*) {
return false;
6076}

6078bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
return Visit(T->getDeducedType());
6080}

6082bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
  const DeducedTemplateSpecializationType *T) {
return Visit(T->getDeducedType());
6085}

6087bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
return VisitTagDecl(T->getDecl());
6089}

6091bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
return VisitTagDecl(T->getDecl());
6093}

6095bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
                                               const TemplateTypeParmType*) {
return false;
6098}

6100bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
                                      const SubstTemplateTypeParmPackType *) {
return false;
6103}

6105bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
                                          const TemplateSpecializationType*) {
return false;
6108}

6110bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
                                            const InjectedClassNameType* T) {
return VisitTagDecl(T->getDecl());
6113}

6115bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
                                                 const DependentNameType* T) {
return VisitNestedNameSpecifier(T->getQualifier());
6118}

6120bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
                               const DependentTemplateSpecializationType* T) {
if (auto *Q = T->getQualifier())
  return VisitNestedNameSpecifier(Q);
return false;
6125}

6127bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
                                                 const PackExpansionType* T) {
return Visit(T->getPattern());
6130}

6132bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
return false;
6134}

6136bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
                                                 const ObjCInterfaceType *) {
return false;
6139}

6141bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
                                              const ObjCObjectPointerType *) {
return false;
6144}

6146bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
return Visit(T->getValueType());
6148}

6150bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
return false;
6152}

6154bool UnnamedLocalNoLinkageFinder::VisitExtIntType(const ExtIntType *T) {
return false;
6156}

6158bool UnnamedLocalNoLinkageFinder::VisitDependentExtIntType(
  const DependentExtIntType *T) {
return false;
6161}

6163bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
if (Tag->getDeclContext()->isFunctionOrMethod()) {
  S.Diag(SR.getBegin(),
         S.getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_template_arg_local_type :
           diag::ext_template_arg_local_type)
    << S.Context.getTypeDeclType(Tag) << SR;
  return true;
}

if (!Tag->hasNameForLinkage()) {
  S.Diag(SR.getBegin(),
         S.getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_template_arg_unnamed_type :
           diag::ext_template_arg_unnamed_type) << SR;
  S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
  return true;
}

return false;
6183}

6185bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
                                                  NestedNameSpecifier *NNS) {
assert(NNS)((void)0);
if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
  return true;

switch (NNS->getKind()) {
case NestedNameSpecifier::Identifier:
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Super:
  return false;

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
  return Visit(QualType(NNS->getAsType(), 0));
}
llvm_unreachable("Invalid NestedNameSpecifier::Kind!")__builtin_unreachable();
6204}

6206/// Check a template argument against its corresponding
6207/// template type parameter.
6208///
6209/// This routine implements the semantics of C++ [temp.arg.type]. It
6210/// returns true if an error occurred, and false otherwise.
6211bool Sema::CheckTemplateArgument(TypeSourceInfo *ArgInfo) {
assert(ArgInfo && "invalid TypeSourceInfo")((void)0);
QualType Arg = ArgInfo->getType();
SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();

if (Arg->isVariablyModifiedType()) {
  return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
} else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
  return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
}

// C++03 [temp.arg.type]p2:
//   A local type, a type with no linkage, an unnamed type or a type
//   compounded from any of these types shall not be used as a
//   template-argument for a template type-parameter.
//
// C++11 allows these, and even in C++03 we allow them as an extension with
// a warning.
if (LangOpts.CPlusPlus11 || Arg->hasUnnamedOrLocalType()) {
  UnnamedLocalNoLinkageFinder Finder(*this, SR);
  (void)Finder.Visit(Context.getCanonicalType(Arg));
}

return false;
6235}

6237enum NullPointerValueKind {
NPV_NotNullPointer,
NPV_NullPointer,
NPV_Error
6241};

6243/// Determine whether the given template argument is a null pointer
6244/// value of the appropriate type.
6245static NullPointerValueKind
6246isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
                                 QualType ParamType, Expr *Arg,
                                 Decl *Entity = nullptr) {
if (Arg->isValueDependent() || Arg->isTypeDependent())
  return NPV_NotNullPointer;

// dllimport'd entities aren't constant but are available inside of template
// arguments.
if (Entity && Entity->hasAttr<DLLImportAttr>())
  return NPV_NotNullPointer;

if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
  llvm_unreachable(__builtin_unreachable()
      "Incomplete parameter type in isNullPointerValueTemplateArgument!")__builtin_unreachable();

if (!S.getLangOpts().CPlusPlus11)
  return NPV_NotNullPointer;

// Determine whether we have a constant expression.
ExprResult ArgRV = S.DefaultFunctionArrayConversion(Arg);
if (ArgRV.isInvalid())
  return NPV_Error;
Arg = ArgRV.get();

Expr::EvalResult EvalResult;
SmallVector<PartialDiagnosticAt, 8> Notes;
EvalResult.Diag = &Notes;
if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
    EvalResult.HasSideEffects) {
  SourceLocation DiagLoc = Arg->getExprLoc();

  // If our only note is the usual "invalid subexpression" note, just point
  // the caret at its location rather than producing an essentially
  // redundant note.
  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
      diag::note_invalid_subexpr_in_const_expr) {
    DiagLoc = Notes[0].first;
    Notes.clear();
  }

  S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
    << Arg->getType() << Arg->getSourceRange();
  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
    S.Diag(Notes[I].first, Notes[I].second);

  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return NPV_Error;
}

// C++11 [temp.arg.nontype]p1:
//   - an address constant expression of type std::nullptr_t
if (Arg->getType()->isNullPtrType())
  return NPV_NullPointer;

//   - a constant expression that evaluates to a null pointer value (4.10); or
//   - a constant expression that evaluates to a null member pointer value
//     (4.11); or
if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
    (EvalResult.Val.isMemberPointer() &&
     !EvalResult.Val.getMemberPointerDecl())) {
  // If our expression has an appropriate type, we've succeeded.
  bool ObjCLifetimeConversion;
  if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
      S.IsQualificationConversion(Arg->getType(), ParamType, false,
                                   ObjCLifetimeConversion))
    return NPV_NullPointer;

  // The types didn't match, but we know we got a null pointer; complain,
  // then recover as if the types were correct.
  S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
    << Arg->getType() << ParamType << Arg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return NPV_NullPointer;
}

// If we don't have a null pointer value, but we do have a NULL pointer
// constant, suggest a cast to the appropriate type.
if (Arg->isNullPointerConstant(S.Context, Expr::NPC_NeverValueDependent)) {
  std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
  S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
      << ParamType << FixItHint::CreateInsertion(Arg->getBeginLoc(), Code)
      << FixItHint::CreateInsertion(S.getLocForEndOfToken(Arg->getEndLoc()),
                                    ")");
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return NPV_NullPointer;
}

// FIXME: If we ever want to support general, address-constant expressions
// as non-type template arguments, we should return the ExprResult here to
// be interpreted by the caller.
return NPV_NotNullPointer;
6337}

6339/// Checks whether the given template argument is compatible with its
6340/// template parameter.
6341static bool CheckTemplateArgumentIsCompatibleWithParameter(
  Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
  Expr *Arg, QualType ArgType) {
bool ObjCLifetimeConversion;
if (ParamType->isPointerType() &&
    !ParamType->castAs<PointerType>()->getPointeeType()->isFunctionType() &&
    S.IsQualificationConversion(ArgType, ParamType, false,
                                ObjCLifetimeConversion)) {
  // For pointer-to-object types, qualification conversions are
  // permitted.
} else {
  if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
    if (!ParamRef->getPointeeType()->isFunctionType()) {
      // C++ [temp.arg.nontype]p5b3:
      //   For a non-type template-parameter of type reference to
      //   object, no conversions apply. The type referred to by the
      //   reference may be more cv-qualified than the (otherwise
      //   identical) type of the template- argument. The
      //   template-parameter is bound directly to the
      //   template-argument, which shall be an lvalue.

      // FIXME: Other qualifiers?
      unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
      unsigned ArgQuals = ArgType.getCVRQualifiers();

      if ((ParamQuals | ArgQuals) != ParamQuals) {
        S.Diag(Arg->getBeginLoc(),
               diag::err_template_arg_ref_bind_ignores_quals)
            << ParamType << Arg->getType() << Arg->getSourceRange();
        S.Diag(Param->getLocation(), diag::note_template_param_here);
        return true;
      }
    }
  }

  // At this point, the template argument refers to an object or
  // function with external linkage. We now need to check whether the
  // argument and parameter types are compatible.
  if (!S.Context.hasSameUnqualifiedType(ArgType,
                                        ParamType.getNonReferenceType())) {
    // We can't perform this conversion or binding.
    if (ParamType->isReferenceType())
      S.Diag(Arg->getBeginLoc(), diag::err_template_arg_no_ref_bind)
          << ParamType << ArgIn->getType() << Arg->getSourceRange();
    else
      S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_convertible)
          << ArgIn->getType() << ParamType << Arg->getSourceRange();
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }
}

return false;
6394}

6396/// Checks whether the given template argument is the address
6397/// of an object or function according to C++ [temp.arg.nontype]p1.
6398static bool
6399CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S,
                                             NonTypeTemplateParmDecl *Param,
                                             QualType ParamType,
                                             Expr *ArgIn,
                                             TemplateArgument &Converted) {
bool Invalid = false;
Expr *Arg = ArgIn;
QualType ArgType = Arg->getType();

bool AddressTaken = false;
SourceLocation AddrOpLoc;
if (S.getLangOpts().MicrosoftExt) {
  // Microsoft Visual C++ strips all casts, allows an arbitrary number of
  // dereference and address-of operators.
  Arg = Arg->IgnoreParenCasts();

  bool ExtWarnMSTemplateArg = false;
  UnaryOperatorKind FirstOpKind;
  SourceLocation FirstOpLoc;
  while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
    UnaryOperatorKind UnOpKind = UnOp->getOpcode();
    if (UnOpKind == UO_Deref)
      ExtWarnMSTemplateArg = true;
    if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
      Arg = UnOp->getSubExpr()->IgnoreParenCasts();
      if (!AddrOpLoc.isValid()) {
        FirstOpKind = UnOpKind;
        FirstOpLoc = UnOp->getOperatorLoc();
      }
    } else
      break;
  }
  if (FirstOpLoc.isValid()) {
    if (ExtWarnMSTemplateArg)
      S.Diag(ArgIn->getBeginLoc(), diag::ext_ms_deref_template_argument)
          << ArgIn->getSourceRange();

    if (FirstOpKind == UO_AddrOf)
      AddressTaken = true;
    else if (Arg->getType()->isPointerType()) {
      // We cannot let pointers get dereferenced here, that is obviously not a
      // constant expression.
      assert(FirstOpKind == UO_Deref)((void)0);
      S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
          << Arg->getSourceRange();
    }
  }
} else {
  // See through any implicit casts we added to fix the type.
  Arg = Arg->IgnoreImpCasts();

  // C++ [temp.arg.nontype]p1:
  //
  //   A template-argument for a non-type, non-template
  //   template-parameter shall be one of: [...]
  //
  //     -- the address of an object or function with external
  //        linkage, including function templates and function
  //        template-ids but excluding non-static class members,
  //        expressed as & id-expression where the & is optional if
  //        the name refers to a function or array, or if the
  //        corresponding template-parameter is a reference; or

  // In C++98/03 mode, give an extension warning on any extra parentheses.
  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
  bool ExtraParens = false;
  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
    if (!Invalid && !ExtraParens) {
      S.Diag(Arg->getBeginLoc(),
             S.getLangOpts().CPlusPlus11
                 ? diag::warn_cxx98_compat_template_arg_extra_parens
                 : diag::ext_template_arg_extra_parens)
          << Arg->getSourceRange();
      ExtraParens = true;
    }

    Arg = Parens->getSubExpr();
  }

  while (SubstNonTypeTemplateParmExpr *subst =
             dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
    Arg = subst->getReplacement()->IgnoreImpCasts();

  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
    if (UnOp->getOpcode() == UO_AddrOf) {
      Arg = UnOp->getSubExpr();
      AddressTaken = true;
      AddrOpLoc = UnOp->getOperatorLoc();
    }
  }

  while (SubstNonTypeTemplateParmExpr *subst =
             dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
    Arg = subst->getReplacement()->IgnoreImpCasts();
}

ValueDecl *Entity = nullptr;
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg))
  Entity = DRE->getDecl();
else if (CXXUuidofExpr *CUE = dyn_cast<CXXUuidofExpr>(Arg))
  Entity = CUE->getGuidDecl();

// If our parameter has pointer type, check for a null template value.
if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn,
                                             Entity)) {
  case NPV_NullPointer:
    S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
    Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
                                 /*isNullPtr=*/true);
    return false;

  case NPV_Error:
    return true;

  case NPV_NotNullPointer:
    break;
  }
}

// Stop checking the precise nature of the argument if it is value dependent,
// it should be checked when instantiated.
if (Arg->isValueDependent()) {
  Converted = TemplateArgument(ArgIn);
  return false;
}

if (!Entity) {
  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
      << Arg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return true;
}

// Cannot refer to non-static data members
if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_field)
      << Entity << Arg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return true;
}

// Cannot refer to non-static member functions
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
  if (!Method->isStatic()) {
    S.Diag(Arg->getBeginLoc(), diag::err_template_arg_method)
        << Method << Arg->getSourceRange();
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }
}

FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
VarDecl *Var = dyn_cast<VarDecl>(Entity);
MSGuidDecl *Guid = dyn_cast<MSGuidDecl>(Entity);

// A non-type template argument must refer to an object or function.
if (!Func && !Var && !Guid) {
  // We found something, but we don't know specifically what it is.
  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_object_or_func)
      << Arg->getSourceRange();
  S.Diag(Entity->getLocation(), diag::note_template_arg_refers_here);
  return true;
}

// Address / reference template args must have external linkage in C++98.
if (Entity->getFormalLinkage() == InternalLinkage) {
  S.Diag(Arg->getBeginLoc(),
         S.getLangOpts().CPlusPlus11
             ? diag::warn_cxx98_compat_template_arg_object_internal
             : diag::ext_template_arg_object_internal)
      << !Func << Entity << Arg->getSourceRange();
  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
    << !Func;
} else if (!Entity->hasLinkage()) {
  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_object_no_linkage)
      << !Func << Entity << Arg->getSourceRange();
  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
    << !Func;
  return true;
}

if (Var) {
  // A value of reference type is not an object.
  if (Var->getType()->isReferenceType()) {
    S.Diag(Arg->getBeginLoc(), diag::err_template_arg_reference_var)
        << Var->getType() << Arg->getSourceRange();
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }

  // A template argument must have static storage duration.
  if (Var->getTLSKind()) {
    S.Diag(Arg->getBeginLoc(), diag::err_template_arg_thread_local)
        << Arg->getSourceRange();
    S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
    return true;
  }
}

if (AddressTaken && ParamType->isReferenceType()) {
  // If we originally had an address-of operator, but the
  // parameter has reference type, complain and (if things look
  // like they will work) drop the address-of operator.
  if (!S.Context.hasSameUnqualifiedType(Entity->getType(),
                                        ParamType.getNonReferenceType())) {
    S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
      << ParamType;
    S.Diag(Param->getLocation(), diag::note_template_param_here);
    return true;
  }

  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
    << ParamType
    << FixItHint::CreateRemoval(AddrOpLoc);
  S.Diag(Param->getLocation(), diag::note_template_param_here);

  ArgType = Entity->getType();
}

// If the template parameter has pointer type, either we must have taken the
// address or the argument must decay to a pointer.
if (!AddressTaken && ParamType->isPointerType()) {
  if (Func) {
    // Function-to-pointer decay.
    ArgType = S.Context.getPointerType(Func->getType());
  } else if (Entity->getType()->isArrayType()) {
    // Array-to-pointer decay.
    ArgType = S.Context.getArrayDecayedType(Entity->getType());
  } else {
    // If the template parameter has pointer type but the address of
    // this object was not taken, complain and (possibly) recover by
    // taking the address of the entity.
    ArgType = S.Context.getPointerType(Entity->getType());
    if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
      S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_address_of)
        << ParamType;
      S.Diag(Param->getLocation(), diag::note_template_param_here);
      return true;
    }

    S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_address_of)
      << ParamType << FixItHint::CreateInsertion(Arg->getBeginLoc(), "&");

    S.Diag(Param->getLocation(), diag::note_template_param_here);
  }
}

if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
                                                   Arg, ArgType))
  return true;

// Create the template argument.
Converted = TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()),
                             S.Context.getCanonicalType(ParamType));
S.MarkAnyDeclReferenced(Arg->getBeginLoc(), Entity, false);
return false;
6656}

6658/// Checks whether the given template argument is a pointer to
6659/// member constant according to C++ [temp.arg.nontype]p1.
6660static bool CheckTemplateArgumentPointerToMember(Sema &S,
                                               NonTypeTemplateParmDecl *Param,
                                               QualType ParamType,
                                               Expr *&ResultArg,
                                               TemplateArgument &Converted) {
bool Invalid = false;

Expr *Arg = ResultArg;
bool ObjCLifetimeConversion;

// C++ [temp.arg.nontype]p1:
//
//   A template-argument for a non-type, non-template
//   template-parameter shall be one of: [...]
//
//     -- a pointer to member expressed as described in 5.3.1.
DeclRefExpr *DRE = nullptr;

// In C++98/03 mode, give an extension warning on any extra parentheses.
// See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
bool ExtraParens = false;
while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
  if (!Invalid && !ExtraParens) {
    S.Diag(Arg->getBeginLoc(),
           S.getLangOpts().CPlusPlus11
               ? diag::warn_cxx98_compat_template_arg_extra_parens
               : diag::ext_template_arg_extra_parens)
        << Arg->getSourceRange();
    ExtraParens = true;
  }

  Arg = Parens->getSubExpr();
}

while (SubstNonTypeTemplateParmExpr *subst =
         dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
  Arg = subst->getReplacement()->IgnoreImpCasts();

// A pointer-to-member constant written &Class::member.
if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
  if (UnOp->getOpcode() == UO_AddrOf) {
    DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
    if (DRE && !DRE->getQualifier())
      DRE = nullptr;
  }
}
// A constant of pointer-to-member type.
else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
  ValueDecl *VD = DRE->getDecl();
  if (VD->getType()->isMemberPointerType()) {
    if (isa<NonTypeTemplateParmDecl>(VD)) {
      if (Arg->isTypeDependent() || Arg->isValueDependent()) {
        Converted = TemplateArgument(Arg);
      } else {
        VD = cast<ValueDecl>(VD->getCanonicalDecl());
        Converted = TemplateArgument(VD, ParamType);
      }
      return Invalid;
    }
  }

  DRE = nullptr;
}

ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;

// Check for a null pointer value.
switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ResultArg,
                                           Entity)) {
case NPV_Error:
  return true;
case NPV_NullPointer:
  S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
                               /*isNullPtr*/true);
  return false;
case NPV_NotNullPointer:
  break;
}

if (S.IsQualificationConversion(ResultArg->getType(),
                                ParamType.getNonReferenceType(), false,
                                ObjCLifetimeConversion)) {
  ResultArg = S.ImpCastExprToType(ResultArg, ParamType, CK_NoOp,
                                  ResultArg->getValueKind())
                  .get();
} else if (!S.Context.hasSameUnqualifiedType(
               ResultArg->getType(), ParamType.getNonReferenceType())) {
  // We can't perform this conversion.
  S.Diag(ResultArg->getBeginLoc(), diag::err_template_arg_not_convertible)
      << ResultArg->getType() << ParamType << ResultArg->getSourceRange();
  S.Diag(Param->getLocation(), diag::note_template_param_here);
  return true;
}

if (!DRE)
  return S.Diag(Arg->getBeginLoc(),
                diag::err_template_arg_not_pointer_to_member_form)
         << Arg->getSourceRange();

if (isa<FieldDecl>(DRE->getDecl()) ||
    isa<IndirectFieldDecl>(DRE->getDecl()) ||
    isa<CXXMethodDecl>(DRE->getDecl())) {
  assert((isa<FieldDecl>(DRE->getDecl()) ||((void)0)
          isa<IndirectFieldDecl>(DRE->getDecl()) ||((void)0)
          !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&((void)0)
         "Only non-static member pointers can make it here")((void)0);

  // Okay: this is the address of a non-static member, and therefore
  // a member pointer constant.
  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
    Converted = TemplateArgument(Arg);
  } else {
    ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
    Converted = TemplateArgument(D, S.Context.getCanonicalType(ParamType));
  }
  return Invalid;
}

// We found something else, but we don't know specifically what it is.
S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
    << Arg->getSourceRange();
S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
return true;
6784}

6786/// Check a template argument against its corresponding
6787/// non-type template parameter.
6788///
6789/// This routine implements the semantics of C++ [temp.arg.nontype].
6790/// If an error occurred, it returns ExprError(); otherwise, it
6791/// returns the converted template argument. \p ParamType is the
6792/// type of the non-type template parameter after it has been instantiated.
6793ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
                                     QualType ParamType, Expr *Arg,
                                     TemplateArgument &Converted,
                                     CheckTemplateArgumentKind CTAK) {
SourceLocation StartLoc = Arg->getBeginLoc();

// If the parameter type somehow involves auto, deduce the type now.
DeducedType *DeducedT = ParamType->getContainedDeducedType();
if (getLangOpts().CPlusPlus17 && DeducedT && !DeducedT->isDeduced()) {
  // During template argument deduction, we allow 'decltype(auto)' to
  // match an arbitrary dependent argument.
  // FIXME: The language rules don't say what happens in this case.
  // FIXME: We get an opaque dependent type out of decltype(auto) if the
  // expression is merely instantiation-dependent; is this enough?
  if (CTAK == CTAK_Deduced && Arg->isTypeDependent()) {
    auto *AT = dyn_cast<AutoType>(DeducedT);
    if (AT && AT->isDecltypeAuto()) {
      Converted = TemplateArgument(Arg);
      return Arg;
    }
  }

  // When checking a deduced template argument, deduce from its type even if
  // the type is dependent, in order to check the types of non-type template
  // arguments line up properly in partial ordering.
  Optional<unsigned> Depth = Param->getDepth() + 1;
  Expr *DeductionArg = Arg;
  if (auto *PE = dyn_cast<PackExpansionExpr>(DeductionArg))
    DeductionArg = PE->getPattern();
  TypeSourceInfo *TSI =
      Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation());
  if (isa<DeducedTemplateSpecializationType>(DeducedT)) {
    InitializedEntity Entity =
        InitializedEntity::InitializeTemplateParameter(ParamType, Param);
    InitializationKind Kind = InitializationKind::CreateForInit(
        DeductionArg->getBeginLoc(), /*DirectInit*/false, DeductionArg);
    Expr *Inits[1] = {DeductionArg};
    ParamType =
        DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind, Inits);
    if (ParamType.isNull())
      return ExprError();
  } else if (DeduceAutoType(
                 TSI, DeductionArg, ParamType, Depth,
                 // We do not check constraints right now because the
                 // immediately-declared constraint of the auto type is also
                 // an associated constraint, and will be checked along with
                 // the other associated constraints after checking the
                 // template argument list.
                 /*IgnoreConstraints=*/true) == DAR_Failed) {
    Diag(Arg->getExprLoc(),
         diag::err_non_type_template_parm_type_deduction_failure)
      << Param->getDeclName() << Param->getType() << Arg->getType()
      << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }
  // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
  // an error. The error message normally references the parameter
  // declaration, but here we'll pass the argument location because that's
  // where the parameter type is deduced.
  ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
  if (ParamType.isNull()) {
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }
}

// We should have already dropped all cv-qualifiers by now.
assert(!ParamType.hasQualifiers() &&((void)0)
       "non-type template parameter type cannot be qualified")((void)0);

// FIXME: When Param is a reference, should we check that Arg is an lvalue?
if (CTAK == CTAK_Deduced &&
    (ParamType->isReferenceType()
         ? !Context.hasSameType(ParamType.getNonReferenceType(),
                                Arg->getType())
         : !Context.hasSameUnqualifiedType(ParamType, Arg->getType()))) {
  // FIXME: If either type is dependent, we skip the check. This isn't
  // correct, since during deduction we're supposed to have replaced each
  // template parameter with some unique (non-dependent) placeholder.
  // FIXME: If the argument type contains 'auto', we carry on and fail the
  // type check in order to force specific types to be more specialized than
  // 'auto'. It's not clear how partial ordering with 'auto' is supposed to
  // work. Similarly for CTAD, when comparing 'A<x>' against 'A'.
  if ((ParamType->isDependentType() || Arg->isTypeDependent()) &&
      !Arg->getType()->getContainedDeducedType()) {
    Converted = TemplateArgument(Arg);
    return Arg;
  }
  // FIXME: This attempts to implement C++ [temp.deduct.type]p17. Per DR1770,
  // we should actually be checking the type of the template argument in P,
  // not the type of the template argument deduced from A, against the
  // template parameter type.
  Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
    << Arg->getType()
    << ParamType.getUnqualifiedType();
  Diag(Param->getLocation(), diag::note_template_param_here);
  return ExprError();
}

// If either the parameter has a dependent type or the argument is
// type-dependent, there's nothing we can check now. The argument only
// contains an unexpanded pack during partial ordering, and there's
// nothing more we can check in that case.
if (ParamType->isDependentType() || Arg->isTypeDependent() ||
    Arg->containsUnexpandedParameterPack()) {
  // Force the argument to the type of the parameter to maintain invariants.
  auto *PE = dyn_cast<PackExpansionExpr>(Arg);
  if (PE)
    Arg = PE->getPattern();
  ExprResult E = ImpCastExprToType(
      Arg, ParamType.getNonLValueExprType(Context), CK_Dependent,
      ParamType->isLValueReferenceType()   ? VK_LValue
      : ParamType->isRValueReferenceType() ? VK_XValue
                                           : VK_PRValue);
  if (E.isInvalid())
    return ExprError();
  if (PE) {
    // Recreate a pack expansion if we unwrapped one.
    E = new (Context)
        PackExpansionExpr(E.get()->getType(), E.get(), PE->getEllipsisLoc(),
                          PE->getNumExpansions());
  }
  Converted = TemplateArgument(E.get());
  return E;
}

// The initialization of the parameter from the argument is
// a constant-evaluated context.
EnterExpressionEvaluationContext ConstantEvaluated(
    *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);

if (getLangOpts().CPlusPlus17) {
  QualType CanonParamType = Context.getCanonicalType(ParamType);

  // Avoid making a copy when initializing a template parameter of class type
  // from a template parameter object of the same type. This is going beyond
  // the standard, but is required for soundness: in
  //   template<A a> struct X { X *p; X<a> *q; };
  // ... we need p and q to have the same type.
  //
  // Similarly, don't inject a call to a copy constructor when initializing
  // from a template parameter of the same type.
  Expr *InnerArg = Arg->IgnoreParenImpCasts();
  if (ParamType->isRecordType() && isa<DeclRefExpr>(InnerArg) &&
      Context.hasSameUnqualifiedType(ParamType, InnerArg->getType())) {
    NamedDecl *ND = cast<DeclRefExpr>(InnerArg)->getDecl();
    if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
      Converted = TemplateArgument(TPO, CanonParamType);
      return Arg;
    }
    if (isa<NonTypeTemplateParmDecl>(ND)) {
      Converted = TemplateArgument(Arg);
      return Arg;
    }
  }

  // C++17 [temp.arg.nontype]p1:
  //   A template-argument for a non-type template parameter shall be
  //   a converted constant expression of the type of the template-parameter.
  APValue Value;
  ExprResult ArgResult = CheckConvertedConstantExpression(
      Arg, ParamType, Value, CCEK_TemplateArg, Param);
  if (ArgResult.isInvalid())
    return ExprError();

  // For a value-dependent argument, CheckConvertedConstantExpression is
  // permitted (and expected) to be unable to determine a value.
  if (ArgResult.get()->isValueDependent()) {
    Converted = TemplateArgument(ArgResult.get());
    return ArgResult;
  }

  // Convert the APValue to a TemplateArgument.
  switch (Value.getKind()) {
  case APValue::None:
    assert(ParamType->isNullPtrType())((void)0);
    Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  case APValue::Indeterminate:
    llvm_unreachable("result of constant evaluation should be initialized")__builtin_unreachable();
    break;
  case APValue::Int:
    assert(ParamType->isIntegralOrEnumerationType())((void)0);
    Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
    break;
  case APValue::MemberPointer: {
    assert(ParamType->isMemberPointerType())((void)0);

    // FIXME: We need TemplateArgument representation and mangling for these.
    if (!Value.getMemberPointerPath().empty()) {
      Diag(Arg->getBeginLoc(),
           diag::err_template_arg_member_ptr_base_derived_not_supported)
          << Value.getMemberPointerDecl() << ParamType
          << Arg->getSourceRange();
      return ExprError();
    }

    auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
    Converted = VD ? TemplateArgument(VD, CanonParamType)
                   : TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  }
  case APValue::LValue: {
    //   For a non-type template-parameter of pointer or reference type,
    //   the value of the constant expression shall not refer to
    assert(ParamType->isPointerType() || ParamType->isReferenceType() ||((void)0)
           ParamType->isNullPtrType())((void)0);
    // -- a temporary object
    // -- a string literal
    // -- the result of a typeid expression, or
    // -- a predefined __func__ variable
    APValue::LValueBase Base = Value.getLValueBase();
    auto *VD = const_cast<ValueDecl *>(Base.dyn_cast<const ValueDecl *>());
    if (Base && (!VD || isa<LifetimeExtendedTemporaryDecl>(VD))) {
      Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
          << Arg->getSourceRange();
      return ExprError();
    }
    // -- a subobject
    // FIXME: Until C++20
    if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
        VD && VD->getType()->isArrayType() &&
        Value.getLValuePath()[0].getAsArrayIndex() == 0 &&
        !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
      // Per defect report (no number yet):
      //   ... other than a pointer to the first element of a complete array
      //       object.
    } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
               Value.isLValueOnePastTheEnd()) {
      Diag(StartLoc, diag::err_non_type_template_arg_subobject)
        << Value.getAsString(Context, ParamType);
      return ExprError();
    }
    assert((VD || !ParamType->isReferenceType()) &&((void)0)
           "null reference should not be a constant expression")((void)0);
    assert((!VD || !ParamType->isNullPtrType()) &&((void)0)
           "non-null value of type nullptr_t?")((void)0);
    Converted = VD ? TemplateArgument(VD, CanonParamType)
                   : TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  }
  case APValue::Struct:
  case APValue::Union:
    // Get or create the corresponding template parameter object.
    Converted = TemplateArgument(
        Context.getTemplateParamObjectDecl(CanonParamType, Value),
        CanonParamType);
    break;
  case APValue::AddrLabelDiff:
    return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
  case APValue::FixedPoint:
  case APValue::Float:
  case APValue::ComplexInt:
  case APValue::ComplexFloat:
  case APValue::Vector:
  case APValue::Array:
    return Diag(StartLoc, diag::err_non_type_template_arg_unsupported)
           << ParamType;
  }

  return ArgResult.get();
}

// C++ [temp.arg.nontype]p5:
//   The following conversions are performed on each expression used
//   as a non-type template-argument. If a non-type
//   template-argument cannot be converted to the type of the
//   corresponding template-parameter then the program is
//   ill-formed.
if (ParamType->isIntegralOrEnumerationType()) {
  // C++11:
  //   -- for a non-type template-parameter of integral or
  //      enumeration type, conversions permitted in a converted
  //      constant expression are applied.
  //
  // C++98:
  //   -- for a non-type template-parameter of integral or
  //      enumeration type, integral promotions (4.5) and integral
  //      conversions (4.7) are applied.

  if (getLangOpts().CPlusPlus11) {
    // C++ [temp.arg.nontype]p1:
    //   A template-argument for a non-type, non-template template-parameter
    //   shall be one of:
    //
    //     -- for a non-type template-parameter of integral or enumeration
    //        type, a converted constant expression of the type of the
    //        template-parameter; or
    llvm::APSInt Value;
    ExprResult ArgResult =
      CheckConvertedConstantExpression(Arg, ParamType, Value,
                                       CCEK_TemplateArg);
    if (ArgResult.isInvalid())
      return ExprError();

    // We can't check arbitrary value-dependent arguments.
    if (ArgResult.get()->isValueDependent()) {
      Converted = TemplateArgument(ArgResult.get());
      return ArgResult;
    }

    // Widen the argument value to sizeof(parameter type). This is almost
    // always a no-op, except when the parameter type is bool. In
    // that case, this may extend the argument from 1 bit to 8 bits.
    QualType IntegerType = ParamType;
    if (const EnumType *Enum = IntegerType->getAs<EnumType>())
      IntegerType = Enum->getDecl()->getIntegerType();
    Value = Value.extOrTrunc(IntegerType->isExtIntType()
                                 ? Context.getIntWidth(IntegerType)
                                 : Context.getTypeSize(IntegerType));

    Converted = TemplateArgument(Context, Value,
                                 Context.getCanonicalType(ParamType));
    return ArgResult;
  }

  ExprResult ArgResult = DefaultLvalueConversion(Arg);
  if (ArgResult.isInvalid())
    return ExprError();
  Arg = ArgResult.get();

  QualType ArgType = Arg->getType();

  // C++ [temp.arg.nontype]p1:
  //   A template-argument for a non-type, non-template
  //   template-parameter shall be one of:
  //
  //     -- an integral constant-expression of integral or enumeration
  //        type; or
  //     -- the name of a non-type template-parameter; or
  llvm::APSInt Value;
  if (!ArgType->isIntegralOrEnumerationType()) {
    Diag(Arg->getBeginLoc(), diag::err_template_arg_not_integral_or_enumeral)
        << ArgType << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  } else if (!Arg->isValueDependent()) {
    class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
      QualType T;

    public:
      TmplArgICEDiagnoser(QualType T) : T(T) { }

      SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
                                           SourceLocation Loc) override {
        return S.Diag(Loc, diag::err_template_arg_not_ice) << T;
      }
    } Diagnoser(ArgType);

    Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser).get();
    if (!Arg)
      return ExprError();
  }

  // From here on out, all we care about is the unqualified form
  // of the argument type.
  ArgType = ArgType.getUnqualifiedType();

  // Try to convert the argument to the parameter's type.
  if (Context.hasSameType(ParamType, ArgType)) {
    // Okay: no conversion necessary
  } else if (ParamType->isBooleanType()) {
    // This is an integral-to-boolean conversion.
    Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
  } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
             !ParamType->isEnumeralType()) {
    // This is an integral promotion or conversion.
    Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
  } else {
    // We can't perform this conversion.
    Diag(Arg->getBeginLoc(), diag::err_template_arg_not_convertible)
        << Arg->getType() << ParamType << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }

  // Add the value of this argument to the list of converted
  // arguments. We use the bitwidth and signedness of the template
  // parameter.
  if (Arg->isValueDependent()) {
    // The argument is value-dependent. Create a new
    // TemplateArgument with the converted expression.
    Converted = TemplateArgument(Arg);
    return Arg;
  }

  QualType IntegerType = Context.getCanonicalType(ParamType);
  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
    IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());

  if (ParamType->isBooleanType()) {
    // Value must be zero or one.
    Value = Value != 0;
    unsigned AllowedBits = Context.getTypeSize(IntegerType);
    if (Value.getBitWidth() != AllowedBits)
      Value = Value.extOrTrunc(AllowedBits);
    Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
  } else {
    llvm::APSInt OldValue = Value;

    // Coerce the template argument's value to the value it will have
    // based on the template parameter's type.
    unsigned AllowedBits = IntegerType->isExtIntType()
                               ? Context.getIntWidth(IntegerType)
                               : Context.getTypeSize(IntegerType);
    if (Value.getBitWidth() != AllowedBits)
      Value = Value.extOrTrunc(AllowedBits);
    Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());

    // Complain if an unsigned parameter received a negative value.
    if (IntegerType->isUnsignedIntegerOrEnumerationType() &&
        (OldValue.isSigned() && OldValue.isNegative())) {
      Diag(Arg->getBeginLoc(), diag::warn_template_arg_negative)
          << toString(OldValue, 10) << toString(Value, 10) << Param->getType()
          << Arg->getSourceRange();
      Diag(Param->getLocation(), diag::note_template_param_here);
    }

    // Complain if we overflowed the template parameter's type.
    unsigned RequiredBits;
    if (IntegerType->isUnsignedIntegerOrEnumerationType())
      RequiredBits = OldValue.getActiveBits();
    else if (OldValue.isUnsigned())
      RequiredBits = OldValue.getActiveBits() + 1;
    else
      RequiredBits = OldValue.getMinSignedBits();
    if (RequiredBits > AllowedBits) {
      Diag(Arg->getBeginLoc(), diag::warn_template_arg_too_large)
          << toString(OldValue, 10) << toString(Value, 10) << Param->getType()
          << Arg->getSourceRange();
      Diag(Param->getLocation(), diag::note_template_param_here);
    }
  }

  Converted = TemplateArgument(Context, Value,
                               ParamType->isEnumeralType()
                                 ? Context.getCanonicalType(ParamType)
                                 : IntegerType);
  return Arg;
}

QualType ArgType = Arg->getType();
DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction

// Handle pointer-to-function, reference-to-function, and
// pointer-to-member-function all in (roughly) the same way.
if (// -- For a non-type template-parameter of type pointer to
    //    function, only the function-to-pointer conversion (4.3) is
    //    applied. If the template-argument represents a set of
    //    overloaded functions (or a pointer to such), the matching
    //    function is selected from the set (13.4).
    (ParamType->isPointerType() &&
     ParamType->castAs<PointerType>()->getPointeeType()->isFunctionType()) ||
    // -- For a non-type template-parameter of type reference to
    //    function, no conversions apply. If the template-argument
    //    represents a set of overloaded functions, the matching
    //    function is selected from the set (13.4).
    (ParamType->isReferenceType() &&
     ParamType->castAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
    // -- For a non-type template-parameter of type pointer to
    //    member function, no conversions apply. If the
    //    template-argument represents a set of overloaded member
    //    functions, the matching member function is selected from
    //    the set (13.4).
    (ParamType->isMemberPointerType() &&
     ParamType->castAs<MemberPointerType>()->getPointeeType()
       ->isFunctionType())) {

  if (Arg->getType() == Context.OverloadTy) {
    if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
                                                              true,
                                                              FoundResult)) {
      if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
        return ExprError();

      Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
      ArgType = Arg->getType();
    } else
      return ExprError();
  }

  if (!ParamType->isMemberPointerType()) {
    if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                       ParamType,
                                                       Arg, Converted))
      return ExprError();
    return Arg;
  }

  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
                                           Converted))
    return ExprError();
  return Arg;
}

if (ParamType->isPointerType()) {
  //   -- for a non-type template-parameter of type pointer to
  //      object, qualification conversions (4.4) and the
  //      array-to-pointer conversion (4.2) are applied.
  // C++0x also allows a value of std::nullptr_t.
  assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&((void)0)
         "Only object pointers allowed here")((void)0);

  if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                     ParamType,
                                                     Arg, Converted))
    return ExprError();
  return Arg;
}

if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
  //   -- For a non-type template-parameter of type reference to
  //      object, no conversions apply. The type referred to by the
  //      reference may be more cv-qualified than the (otherwise
  //      identical) type of the template-argument. The
  //      template-parameter is bound directly to the
  //      template-argument, which must be an lvalue.
  assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&((void)0)
         "Only object references allowed here")((void)0);

  if (Arg->getType() == Context.OverloadTy) {
    if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
                                               ParamRefType->getPointeeType(),
                                                              true,
                                                              FoundResult)) {
      if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
        return ExprError();

      Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
      ArgType = Arg->getType();
    } else
      return ExprError();
  }

  if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                     ParamType,
                                                     Arg, Converted))
    return ExprError();
  return Arg;
}

// Deal with parameters of type std::nullptr_t.
if (ParamType->isNullPtrType()) {
  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
    Converted = TemplateArgument(Arg);
    return Arg;
  }

  switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
  case NPV_NotNullPointer:
    Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
      << Arg->getType() << ParamType;
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();

  case NPV_Error:
    return ExprError();

  case NPV_NullPointer:
    Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
    Converted = TemplateArgument(Context.getCanonicalType(ParamType),
                                 /*isNullPtr*/true);
    return Arg;
  }
}

//     -- For a non-type template-parameter of type pointer to data
//        member, qualification conversions (4.4) are applied.
assert(ParamType->isMemberPointerType() && "Only pointers to members remain")((void)0);

if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
                                         Converted))
  return ExprError();
return Arg;
7368}

7370static void DiagnoseTemplateParameterListArityMismatch(
  Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
  Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);

7374/// Check a template argument against its corresponding
7375/// template template parameter.
7376///
7377/// This routine implements the semantics of C++ [temp.arg.template].
7378/// It returns true if an error occurred, and false otherwise.
7379bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
                                       TemplateParameterList *Params,
                                       TemplateArgumentLoc &Arg) {
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
TemplateDecl *Template = Name.getAsTemplateDecl();
if (!Template) {
  // Any dependent template name is fine.
  assert(Name.isDependent() && "Non-dependent template isn't a declaration?")((void)0);
  return false;
}

if (Template->isInvalidDecl())
  return true;

// C++0x [temp.arg.template]p1:
//   A template-argument for a template template-parameter shall be
//   the name of a class template or an alias template, expressed as an
//   id-expression. When the template-argument names a class template, only
//   primary class templates are considered when matching the
//   template template argument with the corresponding parameter;
//   partial specializations are not considered even if their
//   parameter lists match that of the template template parameter.
//
// Note that we also allow template template parameters here, which
// will happen when we are dealing with, e.g., class template
// partial specializations.
if (!isa<ClassTemplateDecl>(Template) &&
    !isa<TemplateTemplateParmDecl>(Template) &&
    !isa<TypeAliasTemplateDecl>(Template) &&
    !isa<BuiltinTemplateDecl>(Template)) {
  assert(isa<FunctionTemplateDecl>(Template) &&((void)0)
         "Only function templates are possible here")((void)0);
  Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
  Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
    << Template;
}

// C++1z [temp.arg.template]p3: (DR 150)
//   A template-argument matches a template template-parameter P when P
//   is at least as specialized as the template-argument A.
// FIXME: We should enable RelaxedTemplateTemplateArgs by default as it is a
//  defect report resolution from C++17 and shouldn't be introduced by
//  concepts.
if (getLangOpts().RelaxedTemplateTemplateArgs) {
  // Quick check for the common case:
  //   If P contains a parameter pack, then A [...] matches P if each of A's
  //   template parameters matches the corresponding template parameter in
  //   the template-parameter-list of P.
  if (TemplateParameterListsAreEqual(
          Template->getTemplateParameters(), Params, false,
          TPL_TemplateTemplateArgumentMatch, Arg.getLocation()) &&
      // If the argument has no associated constraints, then the parameter is
      // definitely at least as specialized as the argument.
      // Otherwise - we need a more thorough check.
      !Template->hasAssociatedConstraints())
    return false;

  if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
                                                        Arg.getLocation())) {
    // C++2a[temp.func.order]p2
    //   [...] If both deductions succeed, the partial ordering selects the
    //   more constrained template as described by the rules in
    //   [temp.constr.order].
    SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
    Params->getAssociatedConstraints(ParamsAC);
    // C++2a[temp.arg.template]p3
    //   [...] In this comparison, if P is unconstrained, the constraints on A
    //   are not considered.
    if (ParamsAC.empty())
      return false;
    Template->getAssociatedConstraints(TemplateAC);
    bool IsParamAtLeastAsConstrained;
    if (IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC,
                               IsParamAtLeastAsConstrained))
      return true;
    if (!IsParamAtLeastAsConstrained) {
      Diag(Arg.getLocation(),
           diag::err_template_template_parameter_not_at_least_as_constrained)
          << Template << Param << Arg.getSourceRange();
      Diag(Param->getLocation(), diag::note_entity_declared_at) << Param;
      Diag(Template->getLocation(), diag::note_entity_declared_at)
          << Template;
      MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param, ParamsAC, Template,
                                                    TemplateAC);
      return true;
    }
    return false;
  }
  // FIXME: Produce better diagnostics for deduction failures.
}

return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
                                       Params,
                                       true,
                                       TPL_TemplateTemplateArgumentMatch,
                                       Arg.getLocation());
7475}

7477/// Given a non-type template argument that refers to a
7478/// declaration and the type of its corresponding non-type template
7479/// parameter, produce an expression that properly refers to that
7480/// declaration.
7481ExprResult
7482Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
                                            QualType ParamType,
                                            SourceLocation Loc) {
// C++ [temp.param]p8:
//
//   A non-type template-parameter of type "array of T" or
//   "function returning T" is adjusted to be of type "pointer to
//   T" or "pointer to function returning T", respectively.
if (ParamType->isArrayType())
  ParamType = Context.getArrayDecayedType(ParamType);
else if (ParamType->isFunctionType())
  ParamType = Context.getPointerType(ParamType);

// For a NULL non-type template argument, return nullptr casted to the
// parameter's type.
if (Arg.getKind() == TemplateArgument::NullPtr) {
  return ImpCastExprToType(
           new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
                           ParamType,
                           ParamType->getAs<MemberPointerType>()
                             ? CK_NullToMemberPointer
                             : CK_NullToPointer);
}
assert(Arg.getKind() == TemplateArgument::Declaration &&((void)0)
       "Only declaration template arguments permitted here")((void)0);

ValueDecl *VD = Arg.getAsDecl();

CXXScopeSpec SS;
if (ParamType->isMemberPointerType()) {
  // If this is a pointer to member, we need to use a qualified name to
  // form a suitable pointer-to-member constant.
  assert(VD->getDeclContext()->isRecord() &&((void)0)
         (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||((void)0)
          isa<IndirectFieldDecl>(VD)))((void)0);
  QualType ClassType
    = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
  NestedNameSpecifier *Qualifier
    = NestedNameSpecifier::Create(Context, nullptr, false,
                                  ClassType.getTypePtr());
  SS.MakeTrivial(Context, Qualifier, Loc);
}

ExprResult RefExpr = BuildDeclarationNameExpr(
    SS, DeclarationNameInfo(VD->getDeclName(), Loc), VD);
if (RefExpr.isInvalid())
  return ExprError();

// For a pointer, the argument declaration is the pointee. Take its address.
QualType ElemT(RefExpr.get()->getType()->getArrayElementTypeNoTypeQual(), 0);
if (ParamType->isPointerType() && !ElemT.isNull() &&
    Context.hasSimilarType(ElemT, ParamType->getPointeeType())) {
  // Decay an array argument if we want a pointer to its first element.
  RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
  if (RefExpr.isInvalid())
    return ExprError();
} else if (ParamType->isPointerType() || ParamType->isMemberPointerType()) {
  // For any other pointer, take the address (or form a pointer-to-member).
  RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
  if (RefExpr.isInvalid())
    return ExprError();
} else if (ParamType->isRecordType()) {
  assert(isa<TemplateParamObjectDecl>(VD) &&((void)0)
         "arg for class template param not a template parameter object")((void)0);
  // No conversions apply in this case.
  return RefExpr;
} else {
  assert(ParamType->isReferenceType() &&((void)0)
         "unexpected type for decl template argument")((void)0);
}

// At this point we should have the right value category.
assert(ParamType->isReferenceType() == RefExpr.get()->isLValue() &&((void)0)
       "value kind mismatch for non-type template argument")((void)0);

// The type of the template parameter can differ from the type of the
// argument in various ways; convert it now if necessary.
QualType DestExprType = ParamType.getNonLValueExprType(Context);
if (!Context.hasSameType(RefExpr.get()->getType(), DestExprType)) {
  CastKind CK;
  QualType Ignored;
  if (Context.hasSimilarType(RefExpr.get()->getType(), DestExprType) ||
      IsFunctionConversion(RefExpr.get()->getType(), DestExprType, Ignored)) {
    CK = CK_NoOp;
  } else if (ParamType->isVoidPointerType() &&
             RefExpr.get()->getType()->isPointerType()) {
    CK = CK_BitCast;
  } else {
    // FIXME: Pointers to members can need conversion derived-to-base or
    // base-to-derived conversions. We currently don't retain enough
    // information to convert properly (we need to track a cast path or
    // subobject number in the template argument).
    llvm_unreachable(__builtin_unreachable()
        "unexpected conversion required for non-type template argument")__builtin_unreachable();
  }
  RefExpr = ImpCastExprToType(RefExpr.get(), DestExprType, CK,
                              RefExpr.get()->getValueKind());
}

return RefExpr;
7582}

7584/// Construct a new expression that refers to the given
7585/// integral template argument with the given source-location
7586/// information.
7587///
7588/// This routine takes care of the mapping from an integral template
7589/// argument (which may have any integral type) to the appropriate
7590/// literal value.
7591ExprResult
7592Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
                                                SourceLocation Loc) {
assert(Arg.getKind() == TemplateArgument::Integral &&((void)0)
       "Operation is only valid for integral template arguments")((void)0);
QualType OrigT = Arg.getIntegralType();

// If this is an enum type that we're instantiating, we need to use an integer
// type the same size as the enumerator.  We don't want to build an
// IntegerLiteral with enum type.  The integer type of an enum type can be of
// any integral type with C++11 enum classes, make sure we create the right
// type of literal for it.
QualType T = OrigT;
if (const EnumType *ET = OrigT->getAs<EnumType>())
  T = ET->getDecl()->getIntegerType();

Expr *E;
if (T->isAnyCharacterType()) {
  CharacterLiteral::CharacterKind Kind;
  if (T->isWideCharType())
    Kind = CharacterLiteral::Wide;
  else if (T->isChar8Type() && getLangOpts().Char8)
    Kind = CharacterLiteral::UTF8;
  else if (T->isChar16Type())
    Kind = CharacterLiteral::UTF16;
  else if (T->isChar32Type())
    Kind = CharacterLiteral::UTF32;
  else
    Kind = CharacterLiteral::Ascii;

  E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
                                     Kind, T, Loc);
} else if (T->isBooleanType()) {
  E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
                                       T, Loc);
} else if (T->isNullPtrType()) {
  E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
} else {
  E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
}

if (OrigT->isEnumeralType()) {
  // FIXME: This is a hack. We need a better way to handle substituted
  // non-type template parameters.
  E = CStyleCastExpr::Create(Context, OrigT, VK_PRValue, CK_IntegralCast, E,
                             nullptr, CurFPFeatureOverrides(),
                             Context.getTrivialTypeSourceInfo(OrigT, Loc),
                             Loc, Loc);
}

return E;
7642}

7644/// Match two template parameters within template parameter lists.
7645static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
                                     bool Complain,
                                   Sema::TemplateParameterListEqualKind Kind,
                                     SourceLocation TemplateArgLoc) {
// Check the actual kind (type, non-type, template).
if (Old->getKind() != New->getKind()) {
  if (Complain) {
    unsigned NextDiag = diag::err_template_param_different_kind;
    if (TemplateArgLoc.isValid()) {
      S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
      NextDiag = diag::note_template_param_different_kind;
    }
    S.Diag(New->getLocation(), NextDiag)
      << (Kind != Sema::TPL_TemplateMatch);
    S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
      << (Kind != Sema::TPL_TemplateMatch);
  }

  return false;
}

// Check that both are parameter packs or neither are parameter packs.
// However, if we are matching a template template argument to a
// template template parameter, the template template parameter can have
// a parameter pack where the template template argument does not.
if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
    !(Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
      Old->isTemplateParameterPack())) {
  if (Complain) {
    unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
    if (TemplateArgLoc.isValid()) {
      S.Diag(TemplateArgLoc,
           diag::err_template_arg_template_params_mismatch);
      NextDiag = diag::note_template_parameter_pack_non_pack;
    }

    unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
                    : isa<NonTypeTemplateParmDecl>(New)? 1
                    : 2;
    S.Diag(New->getLocation(), NextDiag)
      << ParamKind << New->isParameterPack();
    S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
      << ParamKind << Old->isParameterPack();
  }

  return false;
}

// For non-type template parameters, check the type of the parameter.
if (NonTypeTemplateParmDecl *OldNTTP
                                  = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
  NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);

  // If we are matching a template template argument to a template
  // template parameter and one of the non-type template parameter types
  // is dependent, then we must wait until template instantiation time
  // to actually compare the arguments.
  if (Kind != Sema::TPL_TemplateTemplateArgumentMatch ||
      (!OldNTTP->getType()->isDependentType() &&
       !NewNTTP->getType()->isDependentType()))
    if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
      if (Complain) {
        unsigned NextDiag = diag::err_template_nontype_parm_different_type;
        if (TemplateArgLoc.isValid()) {
          S.Diag(TemplateArgLoc,
                 diag::err_template_arg_template_params_mismatch);
          NextDiag = diag::note_template_nontype_parm_different_type;
        }
        S.Diag(NewNTTP->getLocation(), NextDiag)
          << NewNTTP->getType()
          << (Kind != Sema::TPL_TemplateMatch);
        S.Diag(OldNTTP->getLocation(),
               diag::note_template_nontype_parm_prev_declaration)
          << OldNTTP->getType();
      }

      return false;
    }
}
// For template template parameters, check the template parameter types.
// The template parameter lists of template template
// parameters must agree.
else if (TemplateTemplateParmDecl *OldTTP
                                  = dyn_cast<TemplateTemplateParmDecl>(Old)) {
  TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
  if (!S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
                                        OldTTP->getTemplateParameters(),
                                        Complain,
                                      (Kind == Sema::TPL_TemplateMatch
                                         ? Sema::TPL_TemplateTemplateParmMatch
                                         : Kind),
                                        TemplateArgLoc))
    return false;
} else if (Kind != Sema::TPL_TemplateTemplateArgumentMatch) {
  const Expr *NewC = nullptr, *OldC = nullptr;
  if (const auto *TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())
    NewC = TC->getImmediatelyDeclaredConstraint();
  if (const auto *TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())
    OldC = TC->getImmediatelyDeclaredConstraint();

  auto Diagnose = [&] {
    S.Diag(NewC ? NewC->getBeginLoc() : New->getBeginLoc(),
         diag::err_template_different_type_constraint);
    S.Diag(OldC ? OldC->getBeginLoc() : Old->getBeginLoc(),
         diag::note_template_prev_declaration) << /*declaration*/0;
  };

  if (!NewC != !OldC) {
    if (Complain)
      Diagnose();
    return false;
  }

  if (NewC) {
    llvm::FoldingSetNodeID OldCID, NewCID;
    OldC->Profile(OldCID, S.Context, /*Canonical=*/true);
    NewC->Profile(NewCID, S.Context, /*Canonical=*/true);
    if (OldCID != NewCID) {
      if (Complain)
        Diagnose();
      return false;
    }
  }
}

return true;
7771}

7773/// Diagnose a known arity mismatch when comparing template argument
7774/// lists.
7775static
7776void DiagnoseTemplateParameterListArityMismatch(Sema &S,
                                              TemplateParameterList *New,
                                              TemplateParameterList *Old,
                                    Sema::TemplateParameterListEqualKind Kind,
                                              SourceLocation TemplateArgLoc) {
unsigned NextDiag = diag::err_template_param_list_different_arity;
if (TemplateArgLoc.isValid()) {
  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
  NextDiag = diag::note_template_param_list_different_arity;
}
S.Diag(New->getTemplateLoc(), NextDiag)
  << (New->size() > Old->size())
  << (Kind != Sema::TPL_TemplateMatch)
  << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
  << (Kind != Sema::TPL_TemplateMatch)
  << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
7793}

7795/// Determine whether the given template parameter lists are
7796/// equivalent.
7797///
7798/// \param New  The new template parameter list, typically written in the
7799/// source code as part of a new template declaration.
7800///
7801/// \param Old  The old template parameter list, typically found via
7802/// name lookup of the template declared with this template parameter
7803/// list.
7804///
7805/// \param Complain  If true, this routine will produce a diagnostic if
7806/// the template parameter lists are not equivalent.
7807///
7808/// \param Kind describes how we are to match the template parameter lists.
7809///
7810/// \param TemplateArgLoc If this source location is valid, then we
7811/// are actually checking the template parameter list of a template
7812/// argument (New) against the template parameter list of its
7813/// corresponding template template parameter (Old). We produce
7814/// slightly different diagnostics in this scenario.
7815///
7816/// \returns True if the template parameter lists are equal, false
7817/// otherwise.
7818bool
7819Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
                                   TemplateParameterList *Old,
                                   bool Complain,
                                   TemplateParameterListEqualKind Kind,
                                   SourceLocation TemplateArgLoc) {
if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
  if (Complain)
    DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                               TemplateArgLoc);

  return false;
}

// C++0x [temp.arg.template]p3:
//   A template-argument matches a template template-parameter (call it P)
//   when each of the template parameters in the template-parameter-list of
//   the template-argument's corresponding class template or alias template
//   (call it A) matches the corresponding template parameter in the
//   template-parameter-list of P. [...]
TemplateParameterList::iterator NewParm = New->begin();
TemplateParameterList::iterator NewParmEnd = New->end();
for (TemplateParameterList::iterator OldParm = Old->begin(),
                                  OldParmEnd = Old->end();
     OldParm != OldParmEnd; ++OldParm) {
  if (Kind != TPL_TemplateTemplateArgumentMatch ||
      !(*OldParm)->isTemplateParameterPack()) {
    if (NewParm == NewParmEnd) {
      if (Complain)
        DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                                   TemplateArgLoc);

      return false;
    }

    if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
                                    Kind, TemplateArgLoc))
      return false;

    ++NewParm;
    continue;
  }

  // C++0x [temp.arg.template]p3:
  //   [...] When P's template- parameter-list contains a template parameter
  //   pack (14.5.3), the template parameter pack will match zero or more
  //   template parameters or template parameter packs in the
  //   template-parameter-list of A with the same type and form as the
  //   template parameter pack in P (ignoring whether those template
  //   parameters are template parameter packs).
  for (; NewParm != NewParmEnd; ++NewParm) {
    if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
                                    Kind, TemplateArgLoc))
      return false;
  }
}

// Make sure we exhausted all of the arguments.
if (NewParm != NewParmEnd) {
  if (Complain)
    DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                               TemplateArgLoc);

  return false;
}

if (Kind != TPL_TemplateTemplateArgumentMatch) {
  const Expr *NewRC = New->getRequiresClause();
  const Expr *OldRC = Old->getRequiresClause();

  auto Diagnose = [&] {
    Diag(NewRC ? NewRC->getBeginLoc() : New->getTemplateLoc(),
         diag::err_template_different_requires_clause);
    Diag(OldRC ? OldRC->getBeginLoc() : Old->getTemplateLoc(),
         diag::note_template_prev_declaration) << /*declaration*/0;
  };

  if (!NewRC != !OldRC) {
    if (Complain)
      Diagnose();
    return false;
  }

  if (NewRC) {
    llvm::FoldingSetNodeID OldRCID, NewRCID;
    OldRC->Profile(OldRCID, Context, /*Canonical=*/true);
    NewRC->Profile(NewRCID, Context, /*Canonical=*/true);
    if (OldRCID != NewRCID) {
      if (Complain)
        Diagnose();
      return false;
    }
  }
}

return true;
7914}

7916/// Check whether a template can be declared within this scope.
7917///
7918/// If the template declaration is valid in this scope, returns
7919/// false. Otherwise, issues a diagnostic and returns true.
7920bool
7921Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
if (!S)
  return false;

// Find the nearest enclosing declaration scope.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
       (S->getFlags() & Scope::TemplateParamScope) != 0)
  S = S->getParent();

// C++ [temp.pre]p6: [P2096]
//   A template, explicit specialization, or partial specialization shall not
//   have C linkage.
DeclContext *Ctx = S->getEntity();
if (Ctx && Ctx->isExternCContext()) {
  Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
      << TemplateParams->getSourceRange();
  if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
    Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
  return true;
}
Ctx = Ctx ? Ctx->getRedeclContext() : nullptr;

// C++ [temp]p2:
//   A template-declaration can appear only as a namespace scope or
//   class scope declaration.
// C++ [temp.expl.spec]p3:
//   An explicit specialization may be declared in any scope in which the
//   corresponding primary template may be defined.
// C++ [temp.class.spec]p6: [P2096]
//   A partial specialization may be declared in any scope in which the
//   corresponding primary template may be defined.
if (Ctx) {
  if (Ctx->isFileContext())
    return false;
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
    // C++ [temp.mem]p2:
    //   A local class shall not have member templates.
    if (RD->isLocalClass())
      return Diag(TemplateParams->getTemplateLoc(),
                  diag::err_template_inside_local_class)
        << TemplateParams->getSourceRange();
    else
      return false;
  }
}

return Diag(TemplateParams->getTemplateLoc(),
            diag::err_template_outside_namespace_or_class_scope)
  << TemplateParams->getSourceRange();
7970}

7972/// Determine what kind of template specialization the given declaration
7973/// is.
7974static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) {
if (!D)
  return TSK_Undeclared;

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
  return Record->getTemplateSpecializationKind();
if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
  return Function->getTemplateSpecializationKind();
if (VarDecl *Var = dyn_cast<VarDecl>(D))
  return Var->getTemplateSpecializationKind();

return TSK_Undeclared;
7986}

7988/// Check whether a specialization is well-formed in the current
7989/// context.
7990///
7991/// This routine determines whether a template specialization can be declared
7992/// in the current context (C++ [temp.expl.spec]p2).
7993///
7994/// \param S the semantic analysis object for which this check is being
7995/// performed.
7996///
7997/// \param Specialized the entity being specialized or instantiated, which
7998/// may be a kind of template (class template, function template, etc.) or
7999/// a member of a class template (member function, static data member,
8000/// member class).
8001///
8002/// \param PrevDecl the previous declaration of this entity, if any.
8003///
8004/// \param Loc the location of the explicit specialization or instantiation of
8005/// this entity.
8006///
8007/// \param IsPartialSpecialization whether this is a partial specialization of
8008/// a class template.
8009///
8010/// \returns true if there was an error that we cannot recover from, false
8011/// otherwise.
8012static bool CheckTemplateSpecializationScope(Sema &S,
                                           NamedDecl *Specialized,
                                           NamedDecl *PrevDecl,
                                           SourceLocation Loc,
                                           bool IsPartialSpecialization) {
// Keep these "kind" numbers in sync with the %select statements in the
// various diagnostics emitted by this routine.
int EntityKind = 0;
if (isa<ClassTemplateDecl>(Specialized))
  EntityKind = IsPartialSpecialization? 1 : 0;
else if (isa<VarTemplateDecl>(Specialized))
  EntityKind = IsPartialSpecialization ? 3 : 2;
else if (isa<FunctionTemplateDecl>(Specialized))
  EntityKind = 4;
else if (isa<CXXMethodDecl>(Specialized))
  EntityKind = 5;
else if (isa<VarDecl>(Specialized))
  EntityKind = 6;
else if (isa<RecordDecl>(Specialized))
  EntityKind = 7;
else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
  EntityKind = 8;
else {
  S.Diag(Loc, diag::err_template_spec_unknown_kind)
    << S.getLangOpts().CPlusPlus11;
  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
  return true;
}

// C++ [temp.expl.spec]p2:
//   An explicit specialization may be declared in any scope in which
//   the corresponding primary template may be defined.
if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) {
  S.Diag(Loc, diag::err_template_spec_decl_function_scope)
    << Specialized;
  return true;
}

// C++ [temp.class.spec]p6:
//   A class template partial specialization may be declared in any
//   scope in which the primary template may be defined.
DeclContext *SpecializedContext =
    Specialized->getDeclContext()->getRedeclContext();
DeclContext *DC = S.CurContext->getRedeclContext();

// Make sure that this redeclaration (or definition) occurs in the same
// scope or an enclosing namespace.
if (!(DC->isFileContext() ? DC->Encloses(SpecializedContext)
                          : DC->Equals(SpecializedContext))) {
  if (isa<TranslationUnitDecl>(SpecializedContext))
    S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
      << EntityKind << Specialized;
  else {
    auto *ND = cast<NamedDecl>(SpecializedContext);
    int Diag = diag::err_template_spec_redecl_out_of_scope;
    if (S.getLangOpts().MicrosoftExt && !DC->isRecord())
      Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
    S.Diag(Loc, Diag) << EntityKind << Specialized
                      << ND << isa<CXXRecordDecl>(ND);
  }

  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);

  // Don't allow specializing in the wrong class during error recovery.
  // Otherwise, things can go horribly wrong.
  if (DC->isRecord())
    return true;
}

return false;
8082}

8084static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E) {
if (!E->isTypeDependent())
  return SourceLocation();
DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Checker.TraverseStmt(E);
if (Checker.MatchLoc.isInvalid())
  return E->getSourceRange();
return Checker.MatchLoc;
8092}

8094static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) {
if (!TL.getType()->isDependentType())
  return SourceLocation();
DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Checker.TraverseTypeLoc(TL);
if (Checker.MatchLoc.isInvalid())
  return TL.getSourceRange();
return Checker.MatchLoc;
8102}

8104/// Subroutine of Sema::CheckTemplatePartialSpecializationArgs
8105/// that checks non-type template partial specialization arguments.
8106static bool CheckNonTypeTemplatePartialSpecializationArgs(
  Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
  const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
for (unsigned I = 0; I != NumArgs; ++I) {
  if (Args[I].getKind() == TemplateArgument::Pack) {
    if (CheckNonTypeTemplatePartialSpecializationArgs(
            S, TemplateNameLoc, Param, Args[I].pack_begin(),
            Args[I].pack_size(), IsDefaultArgument))
      return true;

    continue;
  }

  if (Args[I].getKind() != TemplateArgument::Expression)
    continue;

  Expr *ArgExpr = Args[I].getAsExpr();

  // We can have a pack expansion of any of the bullets below.
  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
    ArgExpr = Expansion->getPattern();

  // Strip off any implicit casts we added as part of type checking.
  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
    ArgExpr = ICE->getSubExpr();

  // C++ [temp.class.spec]p8:
  //   A non-type argument is non-specialized if it is the name of a
  //   non-type parameter. All other non-type arguments are
  //   specialized.
  //
  // Below, we check the two conditions that only apply to
  // specialized non-type arguments, so skip any non-specialized
  // arguments.
  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
    if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
      continue;

  // C++ [temp.class.spec]p9:
  //   Within the argument list of a class template partial
  //   specialization, the following restrictions apply:
  //     -- A partially specialized non-type argument expression
  //        shall not involve a template parameter of the partial
  //        specialization except when the argument expression is a
  //        simple identifier.
  //     -- The type of a template parameter corresponding to a
  //        specialized non-type argument shall not be dependent on a
  //        parameter of the specialization.
  // DR1315 removes the first bullet, leaving an incoherent set of rules.
  // We implement a compromise between the original rules and DR1315:
  //     --  A specialized non-type template argument shall not be
  //         type-dependent and the corresponding template parameter
  //         shall have a non-dependent type.
  SourceRange ParamUseRange =
      findTemplateParameterInType(Param->getDepth(), ArgExpr);
  if (ParamUseRange.isValid()) {
    if (IsDefaultArgument) {
      S.Diag(TemplateNameLoc,
             diag::err_dependent_non_type_arg_in_partial_spec);
      S.Diag(ParamUseRange.getBegin(),
             diag::note_dependent_non_type_default_arg_in_partial_spec)
        << ParamUseRange;
    } else {
      S.Diag(ParamUseRange.getBegin(),
             diag::err_dependent_non_type_arg_in_partial_spec)
        << ParamUseRange;
    }
    return true;
  }

  ParamUseRange = findTemplateParameter(
      Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
  if (ParamUseRange.isValid()) {
    S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getBeginLoc(),
           diag::err_dependent_typed_non_type_arg_in_partial_spec)
        << Param->getType();
    S.Diag(Param->getLocation(), diag::note_template_param_here)
      << (IsDefaultArgument ? ParamUseRange : SourceRange())
      << ParamUseRange;
    return true;
  }
}

return false;
8190}

8192/// Check the non-type template arguments of a class template
8193/// partial specialization according to C++ [temp.class.spec]p9.
8194///
8195/// \param TemplateNameLoc the location of the template name.
8196/// \param PrimaryTemplate the template parameters of the primary class
8197///        template.
8198/// \param NumExplicit the number of explicitly-specified template arguments.
8199/// \param TemplateArgs the template arguments of the class template
8200///        partial specialization.
8201///
8202/// \returns \c true if there was an error, \c false otherwise.
8203bool Sema::CheckTemplatePartialSpecializationArgs(
  SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
  unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
// We have to be conservative when checking a template in a dependent
// context.
if (PrimaryTemplate->getDeclContext()->isDependentContext())
  return false;

TemplateParameterList *TemplateParams =
    PrimaryTemplate->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
  NonTypeTemplateParmDecl *Param
    = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
  if (!Param)
    continue;

  if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
                                                    Param, &TemplateArgs[I],
                                                    1, I >= NumExplicit))
    return true;
}

return false;
8226}

8228DeclResult Sema::ActOnClassTemplateSpecialization(
  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
  SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,
  TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,
  MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {
assert(TUK != TUK_Reference && "References are not specializations")((void)0);

// NOTE: KWLoc is the location of the tag keyword. This will instead
// store the location of the outermost template keyword in the declaration.
SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
  ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
SourceLocation LAngleLoc = TemplateId.LAngleLoc;
SourceLocation RAngleLoc = TemplateId.RAngleLoc;

// Find the class template we're specializing
TemplateName Name = TemplateId.Template.get();
ClassTemplateDecl *ClassTemplate
  = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());

if (!ClassTemplate) {
  Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
    << (Name.getAsTemplateDecl() &&
        isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
  return true;
}

bool isMemberSpecialization = false;
bool isPartialSpecialization = false;

// Check the validity of the template headers that introduce this
// template.
// FIXME: We probably shouldn't complain about these headers for
// friend declarations.
bool Invalid = false;
TemplateParameterList *TemplateParams =
    MatchTemplateParametersToScopeSpecifier(
        KWLoc, TemplateNameLoc, SS, &TemplateId,
        TemplateParameterLists, TUK == TUK_Friend, isMemberSpecialization,
        Invalid);
if (Invalid)
  return true;

// Check that we can declare a template specialization here.
if (TemplateParams && CheckTemplateDeclScope(S, TemplateParams))
  return true;

if (TemplateParams && TemplateParams->size() > 0) {
  isPartialSpecialization = true;

  if (TUK == TUK_Friend) {
    Diag(KWLoc, diag::err_partial_specialization_friend)
      << SourceRange(LAngleLoc, RAngleLoc);
    return true;
  }

  // C++ [temp.class.spec]p10:
  //   The template parameter list of a specialization shall not
  //   contain default template argument values.
  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
    Decl *Param = TemplateParams->getParam(I);
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
      if (TTP->hasDefaultArgument()) {
        Diag(TTP->getDefaultArgumentLoc(),
             diag::err_default_arg_in_partial_spec);
        TTP->removeDefaultArgument();
      }
    } else if (NonTypeTemplateParmDecl *NTTP
                 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
      if (Expr *DefArg = NTTP->getDefaultArgument()) {
        Diag(NTTP->getDefaultArgumentLoc(),
             diag::err_default_arg_in_partial_spec)
          << DefArg->getSourceRange();
        NTTP->removeDefaultArgument();
      }
    } else {
      TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
      if (TTP->hasDefaultArgument()) {
        Diag(TTP->getDefaultArgument().getLocation(),
             diag::err_default_arg_in_partial_spec)
          << TTP->getDefaultArgument().getSourceRange();
        TTP->removeDefaultArgument();
      }
    }
  }
} else if (TemplateParams) {
  if (TUK == TUK_Friend)
    Diag(KWLoc, diag::err_template_spec_friend)
      << FixItHint::CreateRemoval(
                              SourceRange(TemplateParams->getTemplateLoc(),
                                          TemplateParams->getRAngleLoc()))
      << SourceRange(LAngleLoc, RAngleLoc);
} else {
  assert(TUK == TUK_Friend && "should have a 'template<>' for this decl")((void)0);
}

// Check that the specialization uses the same tag kind as the
// original template.
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!")((void)0);
if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
                                  Kind, TUK == TUK_Definition, KWLoc,
                                  ClassTemplate->getIdentifier())) {
  Diag(KWLoc, diag::err_use_with_wrong_tag)
    << ClassTemplate
    << FixItHint::CreateReplacement(KWLoc,
                          ClassTemplate->getTemplatedDecl()->getKindName());
  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
       diag::note_previous_use);
  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
}

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs =
    makeTemplateArgumentListInfo(*this, TemplateId);

// Check for unexpanded parameter packs in any of the template arguments.
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
                                      UPPC_PartialSpecialization))
    return true;

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
                              TemplateArgs, false, Converted,
                              /*UpdateArgsWithConversion=*/true))
  return true;

// Find the class template (partial) specialization declaration that
// corresponds to these arguments.
if (isPartialSpecialization) {
  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
                                             TemplateArgs.size(), Converted))
    return true;

  // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
  // also do it during instantiation.
  if (!Name.isDependent() &&
      !TemplateSpecializationType::anyDependentTemplateArguments(TemplateArgs,
                                                                 Converted)) {
    Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
      << ClassTemplate->getDeclName();
    isPartialSpecialization = false;
  }
}

void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl = nullptr;

if (isPartialSpecialization)
  PrevDecl = ClassTemplate->findPartialSpecialization(Converted,
                                                      TemplateParams,
                                                      InsertPos);
else
  PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);

ClassTemplateSpecializationDecl *Specialization = nullptr;

// Check whether we can declare a class template specialization in
// the current scope.
if (TUK != TUK_Friend &&
    CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
                                     TemplateNameLoc,
                                     isPartialSpecialization))
  return true;

// The canonical type
QualType CanonType;
if (isPartialSpecialization) {
  // Build the canonical type that describes the converted template
  // arguments of the class template partial specialization.
  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
  CanonType = Context.getTemplateSpecializationType(CanonTemplate,
                                                    Converted);

  if (Context.hasSameType(CanonType,
                      ClassTemplate->getInjectedClassNameSpecialization()) &&
      (!Context.getLangOpts().CPlusPlus20 ||
       !TemplateParams->hasAssociatedConstraints())) {
    // C++ [temp.class.spec]p9b3:
    //
    //   -- The argument list of the specialization shall not be identical
    //      to the implicit argument list of the primary template.
    //
    // This rule has since been removed, because it's redundant given DR1495,
    // but we keep it because it produces better diagnostics and recovery.
    Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
      << /*class template*/0 << (TUK == TUK_Definition)
      << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
    return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
                              ClassTemplate->getIdentifier(),
                              TemplateNameLoc,
                              Attr,
                              TemplateParams,
                              AS_none, /*ModulePrivateLoc=*/SourceLocation(),
                              /*FriendLoc*/SourceLocation(),
                              TemplateParameterLists.size() - 1,
                              TemplateParameterLists.data());
  }

  // Create a new class template partial specialization declaration node.
  ClassTemplatePartialSpecializationDecl *PrevPartial
    = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
  ClassTemplatePartialSpecializationDecl *Partial
    = ClassTemplatePartialSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                                     KWLoc, TemplateNameLoc,
                                                     TemplateParams,
                                                     ClassTemplate,
                                                     Converted,
                                                     TemplateArgs,
                                                     CanonType,
                                                     PrevPartial);
  SetNestedNameSpecifier(*this, Partial, SS);
  if (TemplateParameterLists.size() > 1 && SS.isSet()) {
    Partial->setTemplateParameterListsInfo(
        Context, TemplateParameterLists.drop_back(1));
  }

  if (!PrevPartial)
    ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
  Specialization = Partial;

  // If we are providing an explicit specialization of a member class
  // template specialization, make a note of that.
  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
    PrevPartial->setMemberSpecialization();

  CheckTemplatePartialSpecialization(Partial);
} else {
  // Create a new class template specialization declaration node for
  // this explicit specialization or friend declaration.
  Specialization
    = ClassTemplateSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                              KWLoc, TemplateNameLoc,
                                              ClassTemplate,
                                              Converted,
                                              PrevDecl);
  SetNestedNameSpecifier(*this, Specialization, SS);
  if (TemplateParameterLists.size() > 0) {
    Specialization->setTemplateParameterListsInfo(Context,
                                                  TemplateParameterLists);
  }

  if (!PrevDecl)
    ClassTemplate->AddSpecialization(Specialization, InsertPos);

  if (CurContext->isDependentContext()) {
    TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
    CanonType = Context.getTemplateSpecializationType(
        CanonTemplate, Converted);
  } else {
    CanonType = Context.getTypeDeclType(Specialization);
  }
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
  bool Okay = false;
  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
    // Is there any previous explicit specialization declaration?
    if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
      Okay = true;
      break;
    }
  }

  if (!Okay) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
      << Context.getTypeDeclType(Specialization) << Range;

    Diag(PrevDecl->getPointOfInstantiation(),
         diag::note_instantiation_required_here)
      << (PrevDecl->getTemplateSpecializationKind()
                                              != TSK_ImplicitInstantiation);
    return true;
  }
}

// If this is not a friend, note that this is an explicit specialization.
if (TUK != TUK_Friend)
  Specialization->setSpecializationKind(TSK_ExplicitSpecialization);

// Check that this isn't a redefinition of this specialization.
if (TUK == TUK_Definition) {
  RecordDecl *Def = Specialization->getDefinition();
  NamedDecl *Hidden = nullptr;
  if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
    SkipBody->ShouldSkip = true;
    SkipBody->Previous = Def;
    makeMergedDefinitionVisible(Hidden);
  } else if (Def) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
    Diag(Def->getLocation(), diag::note_previous_definition);
    Specialization->setInvalidDecl();
    return true;
  }
}

ProcessDeclAttributeList(S, Specialization, Attr);

// Add alignment attributes if necessary; these attributes are checked when
// the ASTContext lays out the structure.
if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) {
  AddAlignmentAttributesForRecord(Specialization);
  AddMsStructLayoutForRecord(Specialization);
}

if (ModulePrivateLoc.isValid())
  Diag(Specialization->getLocation(), diag::err_module_private_specialization)
    << (isPartialSpecialization? 1 : 0)
    << FixItHint::CreateRemoval(ModulePrivateLoc);

// Build the fully-sugared type for this class template
// specialization as the user wrote in the specialization
// itself. This means that we'll pretty-print the type retrieved
// from the specialization's declaration the way that the user
// actually wrote the specialization, rather than formatting the
// name based on the "canonical" representation used to store the
// template arguments in the specialization.
TypeSourceInfo *WrittenTy
  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                              TemplateArgs, CanonType);
if (TUK != TUK_Friend) {
  Specialization->setTypeAsWritten(WrittenTy);
  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
}

// C++ [temp.expl.spec]p9:
//   A template explicit specialization is in the scope of the
//   namespace in which the template was defined.
//
// We actually implement this paragraph where we set the semantic
// context (in the creation of the ClassTemplateSpecializationDecl),
// but we also maintain the lexical context where the actual
// definition occurs.
Specialization->setLexicalDeclContext(CurContext);

// We may be starting the definition of this specialization.
if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip))
  Specialization->startDefinition();

if (TUK == TUK_Friend) {
  FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
                                          TemplateNameLoc,
                                          WrittenTy,
                                          /*FIXME:*/KWLoc);
  Friend->setAccess(AS_public);
  CurContext->addDecl(Friend);
} else {
  // Add the specialization into its lexical context, so that it can
  // be seen when iterating through the list of declarations in that
  // context. However, specializations are not found by name lookup.
  CurContext->addDecl(Specialization);
}

if (SkipBody && SkipBody->ShouldSkip)
  return SkipBody->Previous;

return Specialization;
8598}

8600Decl *Sema::ActOnTemplateDeclarator(Scope *S,
                            MultiTemplateParamsArg TemplateParameterLists,
                                  Declarator &D) {
Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
ActOnDocumentableDecl(NewDecl);
return NewDecl;
8606}

8608Decl *Sema::ActOnConceptDefinition(Scope *S,
                            MultiTemplateParamsArg TemplateParameterLists,
                                 IdentifierInfo *Name, SourceLocation NameLoc,
                                 Expr *ConstraintExpr) {
DeclContext *DC = CurContext;

if (!DC->getRedeclContext()->isFileContext()) {
  Diag(NameLoc,
    diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
  return nullptr;
}

if (TemplateParameterLists.size() > 1) {
  Diag(NameLoc, diag::err_concept_extra_headers);
  return nullptr;
}

if (TemplateParameterLists.front()->size() == 0) {
  Diag(NameLoc, diag::err_concept_no_parameters);
  return nullptr;
}

if (DiagnoseUnexpandedParameterPack(ConstraintExpr))
  return nullptr;

ConceptDecl *NewDecl = ConceptDecl::Create(Context, DC, NameLoc, Name,
                                           TemplateParameterLists.front(),
                                           ConstraintExpr);

if (NewDecl->hasAssociatedConstraints()) {
  // C++2a [temp.concept]p4:
  // A concept shall not have associated constraints.
  Diag(NameLoc, diag::err_concept_no_associated_constraints);
  NewDecl->setInvalidDecl();
}

// Check for conflicting previous declaration.
DeclarationNameInfo NameInfo(NewDecl->getDeclName(), NameLoc);
LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                      ForVisibleRedeclaration);
LookupName(Previous, S);

FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage=*/false,
                     /*AllowInlineNamespace*/false);
if (!Previous.empty()) {
  auto *Old = Previous.getRepresentativeDecl();
  Diag(NameLoc, isa<ConceptDecl>(Old) ? diag::err_redefinition :
       diag::err_redefinition_different_kind) << NewDecl->getDeclName();
  Diag(Old->getLocation(), diag::note_previous_definition);
}

ActOnDocumentableDecl(NewDecl);
PushOnScopeChains(NewDecl, S);
return NewDecl;
8662}

8664/// \brief Strips various properties off an implicit instantiation
8665/// that has just been explicitly specialized.
8666static void StripImplicitInstantiation(NamedDecl *D) {
D->dropAttr<DLLImportAttr>();
D->dropAttr<DLLExportAttr>();

if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
  FD->setInlineSpecified(false);
8672}

8674/// Compute the diagnostic location for an explicit instantiation
8675//  declaration or definition.
8676static SourceLocation DiagLocForExplicitInstantiation(
  NamedDecl* D, SourceLocation PointOfInstantiation) {
// Explicit instantiations following a specialization have no effect and
// hence no PointOfInstantiation. In that case, walk decl backwards
// until a valid name loc is found.
SourceLocation PrevDiagLoc = PointOfInstantiation;
for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
     Prev = Prev->getPreviousDecl()) {
  PrevDiagLoc = Prev->getLocation();
}
assert(PrevDiagLoc.isValid() &&((void)0)
       "Explicit instantiation without point of instantiation?")((void)0);
return PrevDiagLoc;
8689}

8691/// Diagnose cases where we have an explicit template specialization
8692/// before/after an explicit template instantiation, producing diagnostics
8693/// for those cases where they are required and determining whether the
8694/// new specialization/instantiation will have any effect.
8695///
8696/// \param NewLoc the location of the new explicit specialization or
8697/// instantiation.
8698///
8699/// \param NewTSK the kind of the new explicit specialization or instantiation.
8700///
8701/// \param PrevDecl the previous declaration of the entity.
8702///
8703/// \param PrevTSK the kind of the old explicit specialization or instantiatin.
8704///
8705/// \param PrevPointOfInstantiation if valid, indicates where the previus
8706/// declaration was instantiated (either implicitly or explicitly).
8707///
8708/// \param HasNoEffect will be set to true to indicate that the new
8709/// specialization or instantiation has no effect and should be ignored.
8710///
8711/// \returns true if there was an error that should prevent the introduction of
8712/// the new declaration into the AST, false otherwise.
8713bool
8714Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
                                           TemplateSpecializationKind NewTSK,
                                           NamedDecl *PrevDecl,
                                           TemplateSpecializationKind PrevTSK,
                                      SourceLocation PrevPointOfInstantiation,
                                           bool &HasNoEffect) {
HasNoEffect = false;

switch (NewTSK) {
case TSK_Undeclared:
case TSK_ImplicitInstantiation:
  assert(((void)0)
      (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&((void)0)
      "previous declaration must be implicit!")((void)0);
  return false;

case TSK_ExplicitSpecialization:
  switch (PrevTSK) {
  case TSK_Undeclared:
  case TSK_ExplicitSpecialization:
    // Okay, we're just specializing something that is either already
    // explicitly specialized or has merely been mentioned without any
    // instantiation.
    return false;

  case TSK_ImplicitInstantiation:
    if (PrevPointOfInstantiation.isInvalid()) {
      // The declaration itself has not actually been instantiated, so it is
      // still okay to specialize it.
      StripImplicitInstantiation(PrevDecl);
      return false;
    }
    // Fall through
    LLVM_FALLTHROUGH[[gnu::fallthrough]];

  case TSK_ExplicitInstantiationDeclaration:
  case TSK_ExplicitInstantiationDefinition:
    assert((PrevTSK == TSK_ImplicitInstantiation ||((void)0)
            PrevPointOfInstantiation.isValid()) &&((void)0)
           "Explicit instantiation without point of instantiation?")((void)0);

    // C++ [temp.expl.spec]p6:
    //   If a template, a member template or the member of a class template
    //   is explicitly specialized then that specialization shall be declared
    //   before the first use of that specialization that would cause an
    //   implicit instantiation to take place, in every translation unit in
    //   which such a use occurs; no diagnostic is required.
    for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
      // Is there any previous explicit specialization declaration?
      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization)
        return false;
    }

    Diag(NewLoc, diag::err_specialization_after_instantiation)
      << PrevDecl;
    Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
      << (PrevTSK != TSK_ImplicitInstantiation);

    return true;
  }
  llvm_unreachable("The switch over PrevTSK must be exhaustive.")__builtin_unreachable();

case TSK_ExplicitInstantiationDeclaration:
  switch (PrevTSK) {
  case TSK_ExplicitInstantiationDeclaration:
    // This explicit instantiation declaration is redundant (that's okay).
    HasNoEffect = true;
    return false;

  case TSK_Undeclared:
  case TSK_ImplicitInstantiation:
    // We're explicitly instantiating something that may have already been
    // implicitly instantiated; that's fine.
    return false;

  case TSK_ExplicitSpecialization:
    // C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit instantiation
    //   of a template appears after a declaration of an explicit
    //   specialization for that template, the explicit instantiation has no
    //   effect.
    HasNoEffect = true;
    return false;

  case TSK_ExplicitInstantiationDefinition:
    // C++0x [temp.explicit]p10:
    //   If an entity is the subject of both an explicit instantiation
    //   declaration and an explicit instantiation definition in the same
    //   translation unit, the definition shall follow the declaration.
    Diag(NewLoc,
         diag::err_explicit_instantiation_declaration_after_definition);

    // Explicit instantiations following a specialization have no effect and
    // hence no PrevPointOfInstantiation. In that case, walk decl backwards
    // until a valid name loc is found.
    Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
         diag::note_explicit_instantiation_definition_here);
    HasNoEffect = true;
    return false;
  }
  llvm_unreachable("Unexpected TemplateSpecializationKind!")__builtin_unreachable();

case TSK_ExplicitInstantiationDefinition:
  switch (PrevTSK) {
  case TSK_Undeclared:
  case TSK_ImplicitInstantiation:
    // We're explicitly instantiating something that may have already been
    // implicitly instantiated; that's fine.
    return false;

  case TSK_ExplicitSpecialization:
    // C++ DR 259, C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit
    //   instantiation of a template appears after a declaration of
    //   an explicit specialization for that template, the explicit
    //   instantiation has no effect.
    Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
      << PrevDecl;
    Diag(PrevDecl->getLocation(),
         diag::note_previous_template_specialization);
    HasNoEffect = true;
    return false;

  case TSK_ExplicitInstantiationDeclaration:
    // We're explicitly instantiating a definition for something for which we
    // were previously asked to suppress instantiations. That's fine.

    // C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit instantiation
    //   of a template appears after a declaration of an explicit
    //   specialization for that template, the explicit instantiation has no
    //   effect.
    for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
      // Is there any previous explicit specialization declaration?
      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
        HasNoEffect = true;
        break;
      }
    }

    return false;

  case TSK_ExplicitInstantiationDefinition:
    // C++0x [temp.spec]p5:
    //   For a given template and a given set of template-arguments,
    //     - an explicit instantiation definition shall appear at most once
    //       in a program,

    // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
    Diag(NewLoc, (getLangOpts().MSVCCompat)
                     ? diag::ext_explicit_instantiation_duplicate
                     : diag::err_explicit_instantiation_duplicate)
        << PrevDecl;
    Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
         diag::note_previous_explicit_instantiation);
    HasNoEffect = true;
    return false;
  }
}

llvm_unreachable("Missing specialization/instantiation case?")__builtin_unreachable();
8875}

8877/// Perform semantic analysis for the given dependent function
8878/// template specialization.
8879///
8880/// The only possible way to get a dependent function template specialization
8881/// is with a friend declaration, like so:
8882///
8883/// \code
8884///   template \<class T> void foo(T);
8885///   template \<class T> class A {
8886///     friend void foo<>(T);
8887///   };
8888/// \endcode
8889///
8890/// There really isn't any useful analysis we can do here, so we
8891/// just store the information.
8892bool
8893Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
                 const TemplateArgumentListInfo &ExplicitTemplateArgs,
                                                 LookupResult &Previous) {
// Remove anything from Previous that isn't a function template in
// the correct context.
DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
LookupResult::Filter F = Previous.makeFilter();
enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
SmallVector<std::pair<DiscardReason, Decl *>, 8> DiscardedCandidates;
while (F.hasNext()) {
  NamedDecl *D = F.next()->getUnderlyingDecl();
  if (!isa<FunctionTemplateDecl>(D)) {
    F.erase();
    DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate, D));
    continue;
  }

  if (!FDLookupContext->InEnclosingNamespaceSetOf(
          D->getDeclContext()->getRedeclContext())) {
    F.erase();
    DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing, D));
    continue;
  }
}
F.done();

if (Previous.empty()) {
  Diag(FD->getLocation(),
       diag::err_dependent_function_template_spec_no_match);
  for (auto &P : DiscardedCandidates)
    Diag(P.second->getLocation(),
         diag::note_dependent_function_template_spec_discard_reason)
        << P.first;
  return true;
}

FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
                                       ExplicitTemplateArgs);
return false;
8932}

8934/// Perform semantic analysis for the given function template
8935/// specialization.
8936///
8937/// This routine performs all of the semantic analysis required for an
8938/// explicit function template specialization. On successful completion,
8939/// the function declaration \p FD will become a function template
8940/// specialization.
8941///
8942/// \param FD the function declaration, which will be updated to become a
8943/// function template specialization.
8944///
8945/// \param ExplicitTemplateArgs the explicitly-provided template arguments,
8946/// if any. Note that this may be valid info even when 0 arguments are
8947/// explicitly provided as in, e.g., \c void sort<>(char*, char*);
8948/// as it anyway contains info on the angle brackets locations.
8949///
8950/// \param Previous the set of declarations that may be specialized by
8951/// this function specialization.
8952///
8953/// \param QualifiedFriend whether this is a lookup for a qualified friend
8954/// declaration with no explicit template argument list that might be
8955/// befriending a function template specialization.
8956bool Sema::CheckFunctionTemplateSpecialization(
  FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
  LookupResult &Previous, bool QualifiedFriend) {
// The set of function template specializations that could match this
// explicit function template specialization.
UnresolvedSet<8> Candidates;
TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
                                          /*ForTakingAddress=*/false);

llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
    ConvertedTemplateArgs;

DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
       I != E; ++I) {
  NamedDecl *Ovl = (*I)->getUnderlyingDecl();
  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
    // Only consider templates found within the same semantic lookup scope as
    // FD.
    if (!FDLookupContext->InEnclosingNamespaceSetOf(
                              Ovl->getDeclContext()->getRedeclContext()))
      continue;

    // When matching a constexpr member function template specialization
    // against the primary template, we don't yet know whether the
    // specialization has an implicit 'const' (because we don't know whether
    // it will be a static member function until we know which template it
    // specializes), so adjust it now assuming it specializes this template.
    QualType FT = FD->getType();
    if (FD->isConstexpr()) {
      CXXMethodDecl *OldMD =
        dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
      if (OldMD && OldMD->isConst()) {
        const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
        FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
        EPI.TypeQuals.addConst();
        FT = Context.getFunctionType(FPT->getReturnType(),
                                     FPT->getParamTypes(), EPI);
      }
    }

    TemplateArgumentListInfo Args;
    if (ExplicitTemplateArgs)
      Args = *ExplicitTemplateArgs;

    // C++ [temp.expl.spec]p11:
    //   A trailing template-argument can be left unspecified in the
    //   template-id naming an explicit function template specialization
    //   provided it can be deduced from the function argument type.
    // Perform template argument deduction to determine whether we may be
    // specializing this template.
    // FIXME: It is somewhat wasteful to build
    TemplateDeductionInfo Info(FailedCandidates.getLocation());
    FunctionDecl *Specialization = nullptr;
    if (TemplateDeductionResult TDK = DeduceTemplateArguments(
            cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
            ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
            Info)) {
      // Template argument deduction failed; record why it failed, so
      // that we can provide nifty diagnostics.
      FailedCandidates.addCandidate().set(
          I.getPair(), FunTmpl->getTemplatedDecl(),
          MakeDeductionFailureInfo(Context, TDK, Info));
      (void)TDK;
      continue;
    }

    // Target attributes are part of the cuda function signature, so
    // the deduced template's cuda target must match that of the
    // specialization.  Given that C++ template deduction does not
    // take target attributes into account, we reject candidates
    // here that have a different target.
    if (LangOpts.CUDA &&
        IdentifyCUDATarget(Specialization,
                           /* IgnoreImplicitHDAttr = */ true) !=
            IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttr = */ true)) {
      FailedCandidates.addCandidate().set(
          I.getPair(), FunTmpl->getTemplatedDecl(),
          MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
      continue;
    }

    // Record this candidate.
    if (ExplicitTemplateArgs)
      ConvertedTemplateArgs[Specialization] = std::move(Args);
    Candidates.addDecl(Specialization, I.getAccess());
  }
}

// For a qualified friend declaration (with no explicit marker to indicate
// that a template specialization was intended), note all (template and
// non-template) candidates.
if (QualifiedFriend && Candidates.empty()) {
  Diag(FD->getLocation(), diag::err_qualified_friend_no_match)
      << FD->getDeclName() << FDLookupContext;
  // FIXME: We should form a single candidate list and diagnose all
  // candidates at once, to get proper sorting and limiting.
  for (auto *OldND : Previous) {
    if (auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
      NoteOverloadCandidate(OldND, OldFD, CRK_None, FD->getType(), false);
  }
  FailedCandidates.NoteCandidates(*this, FD->getLocation());
  return true;
}

// Find the most specialized function template.
UnresolvedSetIterator Result = getMostSpecialized(
    Candidates.begin(), Candidates.end(), FailedCandidates, FD->getLocation(),
    PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
    PDiag(diag::err_function_template_spec_ambiguous)
        << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
    PDiag(diag::note_function_template_spec_matched));

if (Result == Candidates.end())
  return true;

// Ignore access information;  it doesn't figure into redeclaration checking.
FunctionDecl *Specialization = cast<FunctionDecl>(*Result);

FunctionTemplateSpecializationInfo *SpecInfo
  = Specialization->getTemplateSpecializationInfo();
assert(SpecInfo && "Function template specialization info missing?")((void)0);

// Note: do not overwrite location info if previous template
// specialization kind was explicit.
TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
  Specialization->setLocation(FD->getLocation());
  Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
  // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
  // function can differ from the template declaration with respect to
  // the constexpr specifier.
  // FIXME: We need an update record for this AST mutation.
  // FIXME: What if there are multiple such prior declarations (for instance,
  // from different modules)?
  Specialization->setConstexprKind(FD->getConstexprKind());
}

// FIXME: Check if the prior specialization has a point of instantiation.
// If so, we have run afoul of .

// If this is a friend declaration, then we're not really declaring
// an explicit specialization.
bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);

// Check the scope of this explicit specialization.
if (!isFriend &&
    CheckTemplateSpecializationScope(*this,
                                     Specialization->getPrimaryTemplate(),
                                     Specialization, FD->getLocation(),
                                     false))
  return true;

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
bool HasNoEffect = false;
if (!isFriend &&
    CheckSpecializationInstantiationRedecl(FD->getLocation(),
                                           TSK_ExplicitSpecialization,
                                           Specialization,
                                 SpecInfo->getTemplateSpecializationKind(),
                                       SpecInfo->getPointOfInstantiation(),
                                           HasNoEffect))
  return true;

// Mark the prior declaration as an explicit specialization, so that later
// clients know that this is an explicit specialization.
if (!isFriend) {
  // Since explicit specializations do not inherit '=delete' from their
  // primary function template - check if the 'specialization' that was
  // implicitly generated (during template argument deduction for partial
  // ordering) from the most specialized of all the function templates that
  // 'FD' could have been specializing, has a 'deleted' definition.  If so,
  // first check that it was implicitly generated during template argument
  // deduction by making sure it wasn't referenced, and then reset the deleted
  // flag to not-deleted, so that we can inherit that information from 'FD'.
  if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
      !Specialization->getCanonicalDecl()->isReferenced()) {
    // FIXME: This assert will not hold in the presence of modules.
    assert(((void)0)
        Specialization->getCanonicalDecl() == Specialization &&((void)0)
        "This must be the only existing declaration of this specialization")((void)0);
    // FIXME: We need an update record for this AST mutation.
    Specialization->setDeletedAsWritten(false);
  }
  // FIXME: We need an update record for this AST mutation.
  SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
  MarkUnusedFileScopedDecl(Specialization);
}

// Turn the given function declaration into a function template
// specialization, with the template arguments from the previous
// specialization.
// Take copies of (semantic and syntactic) template argument lists.
const TemplateArgumentList* TemplArgs = new (Context)
  TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
FD->setFunctionTemplateSpecialization(
    Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
    SpecInfo->getTemplateSpecializationKind(),
    ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);

// A function template specialization inherits the target attributes
// of its template.  (We require the attributes explicitly in the
// code to match, but a template may have implicit attributes by
// virtue e.g. of being constexpr, and it passes these implicit
// attributes on to its specializations.)
if (LangOpts.CUDA)
  inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());

// The "previous declaration" for this function template specialization is
// the prior function template specialization.
Previous.clear();
Previous.addDecl(Specialization);
return false;
9174}

9176/// Perform semantic analysis for the given non-template member
9177/// specialization.
9178///
9179/// This routine performs all of the semantic analysis required for an
9180/// explicit member function specialization. On successful completion,
9181/// the function declaration \p FD will become a member function
9182/// specialization.
9183///
9184/// \param Member the member declaration, which will be updated to become a
9185/// specialization.
9186///
9187/// \param Previous the set of declarations, one of which may be specialized
9188/// by this function specialization;  the set will be modified to contain the
9189/// redeclared member.
9190bool
9191Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) {
assert(!isa<TemplateDecl>(Member) && "Only for non-template members")((void)0);

// Try to find the member we are instantiating.
NamedDecl *FoundInstantiation = nullptr;
NamedDecl *Instantiation = nullptr;
NamedDecl *InstantiatedFrom = nullptr;
MemberSpecializationInfo *MSInfo = nullptr;

if (Previous.empty()) {
  // Nowhere to look anyway.
} else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
         I != E; ++I) {
    NamedDecl *D = (*I)->getUnderlyingDecl();
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
      QualType Adjusted = Function->getType();
      if (!hasExplicitCallingConv(Adjusted))
        Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
      // This doesn't handle deduced return types, but both function
      // declarations should be undeduced at this point.
      if (Context.hasSameType(Adjusted, Method->getType())) {
        FoundInstantiation = *I;
        Instantiation = Method;
        InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
        MSInfo = Method->getMemberSpecializationInfo();
        break;
      }
    }
  }
} else if (isa<VarDecl>(Member)) {
  VarDecl *PrevVar;
  if (Previous.isSingleResult() &&
      (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
    if (PrevVar->isStaticDataMember()) {
      FoundInstantiation = Previous.getRepresentativeDecl();
      Instantiation = PrevVar;
      InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
      MSInfo = PrevVar->getMemberSpecializationInfo();
    }
} else if (isa<RecordDecl>(Member)) {
  CXXRecordDecl *PrevRecord;
  if (Previous.isSingleResult() &&
      (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
    FoundInstantiation = Previous.getRepresentativeDecl();
    Instantiation = PrevRecord;
    InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
    MSInfo = PrevRecord->getMemberSpecializationInfo();
  }
} else if (isa<EnumDecl>(Member)) {
  EnumDecl *PrevEnum;
  if (Previous.isSingleResult() &&
      (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
    FoundInstantiation = Previous.getRepresentativeDecl();
    Instantiation = PrevEnum;
    InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
    MSInfo = PrevEnum->getMemberSpecializationInfo();
  }
}

if (!Instantiation) {
  // There is no previous declaration that matches. Since member
  // specializations are always out-of-line, the caller will complain about
  // this mismatch later.
  return false;
}

// A member specialization in a friend declaration isn't really declaring
// an explicit specialization, just identifying a specific (possibly implicit)
// specialization. Don't change the template specialization kind.
//
// FIXME: Is this really valid? Other compilers reject.
if (Member->getFriendObjectKind() != Decl::FOK_None) {
  // Preserve instantiation information.
  if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
    cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
                                    cast<CXXMethodDecl>(InstantiatedFrom),
      cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
  } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
    cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
                                    cast<CXXRecordDecl>(InstantiatedFrom),
      cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
  }

  Previous.clear();
  Previous.addDecl(FoundInstantiation);
  return false;
}

// Make sure that this is a specialization of a member.
if (!InstantiatedFrom) {
  Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
    << Member;
  Diag(Instantiation->getLocation(), diag::note_specialized_decl);
  return true;
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
assert(MSInfo && "Member specialization info missing?")((void)0);

bool HasNoEffect = false;
if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
                                           TSK_ExplicitSpecialization,
                                           Instantiation,
                                   MSInfo->getTemplateSpecializationKind(),
                                         MSInfo->getPointOfInstantiation(),
                                           HasNoEffect))
  return true;

// Check the scope of this explicit specialization.
if (CheckTemplateSpecializationScope(*this,
                                     InstantiatedFrom,
                                     Instantiation, Member->getLocation(),
                                     false))
  return true;

// Note that this member specialization is an "instantiation of" the
// corresponding member of the original template.
if (auto *MemberFunction = dyn_cast<FunctionDecl>(Member)) {
  FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
  if (InstantiationFunction->getTemplateSpecializationKind() ==
        TSK_ImplicitInstantiation) {
    // Explicit specializations of member functions of class templates do not
    // inherit '=delete' from the member function they are specializing.
    if (InstantiationFunction->isDeleted()) {
      // FIXME: This assert will not hold in the presence of modules.
      assert(InstantiationFunction->getCanonicalDecl() ==((void)0)
             InstantiationFunction)((void)0);
      // FIXME: We need an update record for this AST mutation.
      InstantiationFunction->setDeletedAsWritten(false);
    }
  }

  MemberFunction->setInstantiationOfMemberFunction(
      cast<CXXMethodDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberVar = dyn_cast<VarDecl>(Member)) {
  MemberVar->setInstantiationOfStaticDataMember(
      cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberClass = dyn_cast<CXXRecordDecl>(Member)) {
  MemberClass->setInstantiationOfMemberClass(
      cast<CXXRecordDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberEnum = dyn_cast<EnumDecl>(Member)) {
  MemberEnum->setInstantiationOfMemberEnum(
      cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else {
  llvm_unreachable("unknown member specialization kind")__builtin_unreachable();
}

// Save the caller the trouble of having to figure out which declaration
// this specialization matches.
Previous.clear();
Previous.addDecl(FoundInstantiation);
return false;
9349}

9351/// Complete the explicit specialization of a member of a class template by
9352/// updating the instantiated member to be marked as an explicit specialization.
9353///
9354/// \param OrigD The member declaration instantiated from the template.
9355/// \param Loc The location of the explicit specialization of the member.
9356template<typename DeclT>
9357static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD,
                                           SourceLocation Loc) {
if (OrigD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
  return;

// FIXME: Inform AST mutation listeners of this AST mutation.
// FIXME: If there are multiple in-class declarations of the member (from
// multiple modules, or a declaration and later definition of a member type),
// should we update all of them?
OrigD->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
OrigD->setLocation(Loc);
9368}

9370void Sema::CompleteMemberSpecialization(NamedDecl *Member,
                                      LookupResult &Previous) {
NamedDecl *Instantiation = cast<NamedDecl>(Member->getCanonicalDecl());
if (Instantiation == Member)
  return;

if (auto *Function = dyn_cast<CXXMethodDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Function, Member->getLocation());
else if (auto *Var = dyn_cast<VarDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Var, Member->getLocation());
else if (auto *Record = dyn_cast<CXXRecordDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Record, Member->getLocation());
else if (auto *Enum = dyn_cast<EnumDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Enum, Member->getLocation());
else
  llvm_unreachable("unknown member specialization kind")__builtin_unreachable();
9386}

9388/// Check the scope of an explicit instantiation.
9389///
9390/// \returns true if a serious error occurs, false otherwise.
9391static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D,
                                          SourceLocation InstLoc,
                                          bool WasQualifiedName) {
DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
DeclContext *CurContext = S.CurContext->getRedeclContext();

if (CurContext->isRecord()) {
  S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
    << D;
  return true;
}

// C++11 [temp.explicit]p3:
//   An explicit instantiation shall appear in an enclosing namespace of its
//   template. If the name declared in the explicit instantiation is an
//   unqualified name, the explicit instantiation shall appear in the
//   namespace where its template is declared or, if that namespace is inline
//   (7.3.1), any namespace from its enclosing namespace set.
//
// This is DR275, which we do not retroactively apply to C++98/03.
if (WasQualifiedName) {
  if (CurContext->Encloses(OrigContext))
    return false;
} else {
  if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
    return false;
}

if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
  if (WasQualifiedName)
    S.Diag(InstLoc,
           S.getLangOpts().CPlusPlus11?
             diag::err_explicit_instantiation_out_of_scope :
             diag::warn_explicit_instantiation_out_of_scope_0x)
      << D << NS;
  else
    S.Diag(InstLoc,
           S.getLangOpts().CPlusPlus11?
             diag::err_explicit_instantiation_unqualified_wrong_namespace :
             diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
      << D << NS;
} else
  S.Diag(InstLoc,
         S.getLangOpts().CPlusPlus11?
           diag::err_explicit_instantiation_must_be_global :
           diag::warn_explicit_instantiation_must_be_global_0x)
    << D;
S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
return false;
9440}

9442/// Common checks for whether an explicit instantiation of \p D is valid.
9443static bool CheckExplicitInstantiation(Sema &S, NamedDecl *D,
                                     SourceLocation InstLoc,
                                     bool WasQualifiedName,
                                     TemplateSpecializationKind TSK) {
// C++ [temp.explicit]p13:
//   An explicit instantiation declaration shall not name a specialization of
//   a template with internal linkage.
if (TSK == TSK_ExplicitInstantiationDeclaration &&
    D->getFormalLinkage() == InternalLinkage) {
  S.Diag(InstLoc, diag::err_explicit_instantiation_internal_linkage) << D;
  return true;
}

// C++11 [temp.explicit]p3: [DR 275]
//   An explicit instantiation shall appear in an enclosing namespace of its
//   template.
if (CheckExplicitInstantiationScope(S, D, InstLoc, WasQualifiedName))
  return true;

return false;
9463}

9465/// Determine whether the given scope specifier has a template-id in it.
9466static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) {
if (!SS.isSet())
  return false;

// C++11 [temp.explicit]p3:
//   If the explicit instantiation is for a member function, a member class
//   or a static data member of a class template specialization, the name of
//   the class template specialization in the qualified-id for the member
//   name shall be a simple-template-id.
//
// C++98 has the same restriction, just worded differently.
for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
     NNS = NNS->getPrefix())
  if (const Type *T = NNS->getAsType())
    if (isa<TemplateSpecializationType>(T))
      return true;

return false;
9484}

9486/// Make a dllexport or dllimport attr on a class template specialization take
9487/// effect.
9488static void dllExportImportClassTemplateSpecialization(
  Sema &S, ClassTemplateSpecializationDecl *Def) {
auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
assert(A && "dllExportImportClassTemplateSpecialization called "((void)0)
            "on Def without dllexport or dllimport")((void)0);

// We reject explicit instantiations in class scope, so there should
// never be any delayed exported classes to worry about.
assert(S.DelayedDllExportClasses.empty() &&((void)0)
       "delayed exports present at explicit instantiation")((void)0);
S.checkClassLevelDLLAttribute(Def);

// Propagate attribute to base class templates.
for (auto &B : Def->bases()) {
  if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
          B.getType()->getAsCXXRecordDecl()))
    S.propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getBeginLoc());
}

S.referenceDLLExportedClassMethods();
9508}

9510// Explicit instantiation of a class template specialization
9511DeclResult Sema::ActOnExplicitInstantiation(
  Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
  unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
  TemplateTy TemplateD, SourceLocation TemplateNameLoc,
  SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn,
  SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {
// Find the class template we're specializing
TemplateName Name = TemplateD.get();
TemplateDecl *TD = Name.getAsTemplateDecl();
// Check that the specialization uses the same tag kind as the
// original template.
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum &&((void)0)
       "Invalid enum tag in class template explicit instantiation!")((void)0);

ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);

if (!ClassTemplate) {
  NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
  Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
  Diag(TD->getLocation(), diag::note_previous_use);
  return true;
}

if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
                                  Kind, /*isDefinition*/false, KWLoc,
                                  ClassTemplate->getIdentifier())) {
  Diag(KWLoc, diag::err_use_with_wrong_tag)
    << ClassTemplate
    << FixItHint::CreateReplacement(KWLoc,
                          ClassTemplate->getTemplatedDecl()->getKindName());
  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
       diag::note_previous_use);
  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
}

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK = ExternLoc.isInvalid()
                                     ? TSK_ExplicitInstantiationDefinition
                                     : TSK_ExplicitInstantiationDeclaration;

if (TSK == TSK_ExplicitInstantiationDeclaration &&
    !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
  // Check for dllexport class template instantiation declarations,
  // except for MinGW mode.
  for (const ParsedAttr &AL : Attr) {
    if (AL.getKind() == ParsedAttr::AT_DLLExport) {
      Diag(ExternLoc,
           diag::warn_attribute_dllexport_explicit_instantiation_decl);
      Diag(AL.getLoc(), diag::note_attribute);
      break;
    }
  }

  if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
    Diag(ExternLoc,
         diag::warn_attribute_dllexport_explicit_instantiation_decl);
    Diag(A->getLocation(), diag::note_attribute);
  }
}

// In MSVC mode, dllimported explicit instantiation definitions are treated as
// instantiation declarations for most purposes.
bool DLLImportExplicitInstantiationDef = false;
if (TSK == TSK_ExplicitInstantiationDefinition &&
    Context.getTargetInfo().getCXXABI().isMicrosoft()) {
  // Check for dllimport class template instantiation definitions.
  bool DLLImport =
      ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
  for (const ParsedAttr &AL : Attr) {
    if (AL.getKind() == ParsedAttr::AT_DLLImport)
      DLLImport = true;
    if (AL.getKind() == ParsedAttr::AT_DLLExport) {
      // dllexport trumps dllimport here.
      DLLImport = false;
      break;
    }
  }
  if (DLLImport) {
    TSK = TSK_ExplicitInstantiationDeclaration;
    DLLImportExplicitInstantiationDef = true;
  }
}

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

// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> Converted;
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
                              TemplateArgs, false, Converted,
                              /*UpdateArgsWithConversion=*/true))
  return true;

// Find the class template specialization declaration that
// corresponds to these arguments.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl
  = ClassTemplate->findSpecialization(Converted, InsertPos);

TemplateSpecializationKind PrevDecl_TSK
  = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;

if (TSK == TSK_ExplicitInstantiationDefinition && PrevDecl != nullptr &&
    Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
  // Check for dllexport class template instantiation definitions in MinGW
  // mode, if a previous declaration of the instantiation was seen.
  for (const ParsedAttr &AL : Attr) {
    if (AL.getKind() == ParsedAttr::AT_DLLExport) {
      Diag(AL.getLoc(),
           diag::warn_attribute_dllexport_explicit_instantiation_def);
      break;
    }
  }
}

if (CheckExplicitInstantiation(*this, ClassTemplate, TemplateNameLoc,
                               SS.isSet(), TSK))
  return true;

ClassTemplateSpecializationDecl *Specialization = nullptr;

bool HasNoEffect = false;
if (PrevDecl) {
  if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
                                             PrevDecl, PrevDecl_TSK,
                                          PrevDecl->getPointOfInstantiation(),
                                             HasNoEffect))
    return PrevDecl;

  // Even though HasNoEffect == true means that this explicit instantiation
  // has no effect on semantics, we go on to put its syntax in the AST.

  if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
      PrevDecl_TSK == TSK_Undeclared) {
    // Since the only prior class template specialization with these
    // arguments was referenced but not declared, reuse that
    // declaration node as our own, updating the source location
    // for the template name to reflect our new declaration.
    // (Other source locations will be updated later.)
    Specialization = PrevDecl;
    Specialization->setLocation(TemplateNameLoc);
    PrevDecl = nullptr;
  }

  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
      DLLImportExplicitInstantiationDef) {
    // The new specialization might add a dllimport attribute.
    HasNoEffect = false;
  }
}

if (!Specialization) {
  // Create a new class template specialization declaration node for
  // this explicit specialization.
  Specialization
    = ClassTemplateSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                              KWLoc, TemplateNameLoc,
                                              ClassTemplate,
                                              Converted,
                                              PrevDecl);
  SetNestedNameSpecifier(*this, Specialization, SS);

  if (!HasNoEffect && !PrevDecl) {
    // Insert the new specialization.
    ClassTemplate->AddSpecialization(Specialization, InsertPos);
  }
}

// Build the fully-sugared type for this explicit instantiation as
// the user wrote in the explicit instantiation itself. This means
// that we'll pretty-print the type retrieved from the
// specialization's declaration the way that the user actually wrote
// the explicit instantiation, rather than formatting the name based
// on the "canonical" representation used to store the template
// arguments in the specialization.
TypeSourceInfo *WrittenTy
  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                              TemplateArgs,
                                Context.getTypeDeclType(Specialization));
Specialization->setTypeAsWritten(WrittenTy);

// Set source locations for keywords.
Specialization->setExternLoc(ExternLoc);
Specialization->setTemplateKeywordLoc(TemplateLoc);
Specialization->setBraceRange(SourceRange());

bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
ProcessDeclAttributeList(S, Specialization, Attr);

// Add the explicit instantiation into its lexical context. However,
// since explicit instantiations are never found by name lookup, we
// just put it into the declaration context directly.
Specialization->setLexicalDeclContext(CurContext);
CurContext->addDecl(Specialization);

// Syntax is now OK, so return if it has no other effect on semantics.
if (HasNoEffect) {
  // Set the template specialization kind.
  Specialization->setTemplateSpecializationKind(TSK);
  return Specialization;
}

// C++ [temp.explicit]p3:
//   A definition of a class template or class member template
//   shall be in scope at the point of the explicit instantiation of
//   the class template or class member template.
//
// This check comes when we actually try to perform the
// instantiation.
ClassTemplateSpecializationDecl *Def
  = cast_or_null<ClassTemplateSpecializationDecl>(
                                            Specialization->getDefinition());
if (!Def)
  InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
else if (TSK == TSK_ExplicitInstantiationDefinition) {
  MarkVTableUsed(TemplateNameLoc, Specialization, true);
  Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
}

// Instantiate the members of this class template specialization.
Def = cast_or_null<ClassTemplateSpecializationDecl>(
                                     Specialization->getDefinition());
if (Def) {
  TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind();
  // Fix a TSK_ExplicitInstantiationDeclaration followed by a
  // TSK_ExplicitInstantiationDefinition
  if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
      (TSK == TSK_ExplicitInstantiationDefinition ||
       DLLImportExplicitInstantiationDef)) {
    // FIXME: Need to notify the ASTMutationListener that we did this.
    Def->setTemplateSpecializationKind(TSK);

    if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
        (Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
         !Context.getTargetInfo().getTriple().isPS4CPU())) {
      // An explicit instantiation definition can add a dll attribute to a
      // template with a previous instantiation declaration. MinGW doesn't
      // allow this.
      auto *A = cast<InheritableAttr>(
          getDLLAttr(Specialization)->clone(getASTContext()));
      A->setInherited(true);
      Def->addAttr(A);
      dllExportImportClassTemplateSpecialization(*this, Def);
    }
  }

  // Fix a TSK_ImplicitInstantiation followed by a
  // TSK_ExplicitInstantiationDefinition
  bool NewlyDLLExported =
      !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
  if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
      (Context.getTargetInfo().shouldDLLImportComdatSymbols() &&
       !Context.getTargetInfo().getTriple().isPS4CPU())) {
    // An explicit instantiation definition can add a dll attribute to a
    // template with a previous implicit instantiation. MinGW doesn't allow
    // this. We limit clang to only adding dllexport, to avoid potentially
    // strange codegen behavior. For example, if we extend this conditional
    // to dllimport, and we have a source file calling a method on an
    // implicitly instantiated template class instance and then declaring a
    // dllimport explicit instantiation definition for the same template
    // class, the codegen for the method call will not respect the dllimport,
    // while it will with cl. The Def will already have the DLL attribute,
    // since the Def and Specialization will be the same in the case of
    // Old_TSK == TSK_ImplicitInstantiation, and we already added the
    // attribute to the Specialization; we just need to make it take effect.
    assert(Def == Specialization &&((void)0)
           "Def and Specialization should match for implicit instantiation")((void)0);
    dllExportImportClassTemplateSpecialization(*this, Def);
  }

  // In MinGW mode, export the template instantiation if the declaration
  // was marked dllexport.
  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
      Context.getTargetInfo().getTriple().isWindowsGNUEnvironment() &&
      PrevDecl->hasAttr<DLLExportAttr>()) {
    dllExportImportClassTemplateSpecialization(*this, Def);
  }

  if (Def->hasAttr<MSInheritanceAttr>()) {
    Specialization->addAttr(Def->getAttr<MSInheritanceAttr>());
    Consumer.AssignInheritanceModel(Specialization);
  }

  // Set the template specialization kind. Make sure it is set before
  // instantiating the members which will trigger ASTConsumer callbacks.
  Specialization->setTemplateSpecializationKind(TSK);
  InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
} else {

  // Set the template specialization kind.
  Specialization->setTemplateSpecializationKind(TSK);
}

return Specialization;
9812}

9814// Explicit instantiation of a member class of a class template.
9815DeclResult
9816Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
                               SourceLocation TemplateLoc, unsigned TagSpec,
                               SourceLocation KWLoc, CXXScopeSpec &SS,
                               IdentifierInfo *Name, SourceLocation NameLoc,
                               const ParsedAttributesView &Attr) {

bool Owned = false;
bool IsDependent = false;
Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
                      KWLoc, SS, Name, NameLoc, Attr, AS_none,
                      /*ModulePrivateLoc=*/SourceLocation(),
                      MultiTemplateParamsArg(), Owned, IsDependent,
                      SourceLocation(), false, TypeResult(),
                      /*IsTypeSpecifier*/false,
                      /*IsTemplateParamOrArg*/false);
assert(!IsDependent && "explicit instantiation of dependent name not yet handled")((void)0);

if (!TagD)
  return true;

TagDecl *Tag = cast<TagDecl>(TagD);
assert(!Tag->isEnum() && "shouldn't see enumerations here")((void)0);

if (Tag->isInvalidDecl())
  return true;

CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
if (!Pattern) {
  Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
    << Context.getTypeDeclType(Record);
  Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
  return true;
}

// C++0x [temp.explicit]p2:
//   If the explicit instantiation is for a class or member class, the
//   elaborated-type-specifier in the declaration shall include a
//   simple-template-id.
//
// C++98 has the same restriction, just worded differently.
if (!ScopeSpecifierHasTemplateId(SS))
  Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
    << Record << SS.getRange();

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK
  = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                         : TSK_ExplicitInstantiationDeclaration;

CheckExplicitInstantiation(*this, Record, NameLoc, true, TSK);

// Verify that it is okay to explicitly instantiate here.
CXXRecordDecl *PrevDecl
  = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
if (!PrevDecl && Record->getDefinition())
  PrevDecl = Record;
if (PrevDecl) {
  MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo();
  bool HasNoEffect = false;
  assert(MSInfo && "No member specialization information?")((void)0);
  if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
                                             PrevDecl,
                                      MSInfo->getTemplateSpecializationKind(),
                                           MSInfo->getPointOfInstantiation(),
                                             HasNoEffect))
    return true;
  if (HasNoEffect)
    return TagD;
}

CXXRecordDecl *RecordDef
  = cast_or_null<CXXRecordDecl>(Record->getDefinition());
if (!RecordDef) {
  // C++ [temp.explicit]p3:
  //   A definition of a member class of a class template shall be in scope
  //   at the point of an explicit instantiation of the member class.
  CXXRecordDecl *Def
    = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
  if (!Def) {
    Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
      << 0 << Record->getDeclName() << Record->getDeclContext();
    Diag(Pattern->getLocation(), diag::note_forward_declaration)
      << Pattern;
    return true;
  } else {
    if (InstantiateClass(NameLoc, Record, Def,
                         getTemplateInstantiationArgs(Record),
                         TSK))
      return true;

    RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
    if (!RecordDef)
      return true;
  }
}

// Instantiate all of the members of the class.
InstantiateClassMembers(NameLoc, RecordDef,
                        getTemplateInstantiationArgs(Record), TSK);

if (TSK == TSK_ExplicitInstantiationDefinition)
  MarkVTableUsed(NameLoc, RecordDef, true);

// FIXME: We don't have any representation for explicit instantiations of
// member classes. Such a representation is not needed for compilation, but it
// should be available for clients that want to see all of the declarations in
// the source code.
return TagD;
9928}

9930DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
                                          SourceLocation ExternLoc,
                                          SourceLocation TemplateLoc,
                                          Declarator &D) {
// Explicit instantiations always require a name.
// TODO: check if/when DNInfo should replace Name.
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
if (!Name) {
  if (!D.isInvalidType())
    Diag(D.getDeclSpec().getBeginLoc(),
         diag::err_explicit_instantiation_requires_name)
        << D.getDeclSpec().getSourceRange() << D.getSourceRange();

  return true;
}

// The scope passed in may not be a decl scope.  Zip up the scope tree until
// we find one that is.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
       (S->getFlags() & Scope::TemplateParamScope) != 0)
  S = S->getParent();

// Determine the type of the declaration.
TypeSourceInfo *T = GetTypeForDeclarator(D, S);
QualType R = T->getType();
if (R.isNull())
  return true;

// C++ [dcl.stc]p1:
//   A storage-class-specifier shall not be specified in [...] an explicit
//   instantiation (14.7.2) directive.
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
    << Name;
  return true;
} else if (D.getDeclSpec().getStorageClassSpec()
                                              != DeclSpec::SCS_unspecified) {
  // Complain about then remove the storage class specifier.
  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
    << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());

  D.getMutableDeclSpec().ClearStorageClassSpecs();
}

// C++0x [temp.explicit]p1:
//   [...] An explicit instantiation of a function template shall not use the
//   inline or constexpr specifiers.
// Presumably, this also applies to member functions of class templates as
// well.
if (D.getDeclSpec().isInlineSpecified())
  Diag(D.getDeclSpec().getInlineSpecLoc(),
       getLangOpts().CPlusPlus11 ?
         diag::err_explicit_instantiation_inline :
         diag::warn_explicit_instantiation_inline_0x)
    << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
if (D.getDeclSpec().hasConstexprSpecifier() && R->isFunctionType())
  // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
  // not already specified.
  Diag(D.getDeclSpec().getConstexprSpecLoc(),
       diag::err_explicit_instantiation_constexpr);

// A deduction guide is not on the list of entities that can be explicitly
// instantiated.
if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
  Diag(D.getDeclSpec().getBeginLoc(), diag::err_deduction_guide_specialized)
      << /*explicit instantiation*/ 0;
  return true;
}

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK
  = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                         : TSK_ExplicitInstantiationDeclaration;

LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
LookupParsedName(Previous, S, &D.getCXXScopeSpec());

if (!R->isFunctionType()) {
  // C++ [temp.explicit]p1:
  //   A [...] static data member of a class template can be explicitly
  //   instantiated from the member definition associated with its class
  //   template.
  // C++1y [temp.explicit]p1:
  //   A [...] variable [...] template specialization can be explicitly
  //   instantiated from its template.
  if (Previous.isAmbiguous())
    return true;

  VarDecl *Prev = Previous.getAsSingle<VarDecl>();
  VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();

  if (!PrevTemplate) {
    if (!Prev || !Prev->isStaticDataMember()) {
      // We expect to see a static data member here.
      Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
          << Name;
      for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
           P != PEnd; ++P)
        Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
      return true;
    }

    if (!Prev->getInstantiatedFromStaticDataMember()) {
      // FIXME: Check for explicit specialization?
      Diag(D.getIdentifierLoc(),
           diag::err_explicit_instantiation_data_member_not_instantiated)
          << Prev;
      Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
      // FIXME: Can we provide a note showing where this was declared?
      return true;
    }
  } else {
    // Explicitly instantiate a variable template.

    // C++1y [dcl.spec.auto]p6:
    //   ... A program that uses auto or decltype(auto) in a context not
    //   explicitly allowed in this section is ill-formed.
    //
    // This includes auto-typed variable template instantiations.
    if (R->isUndeducedType()) {
      Diag(T->getTypeLoc().getBeginLoc(),
           diag::err_auto_not_allowed_var_inst);
      return true;
    }

    if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
      // C++1y [temp.explicit]p3:
      //   If the explicit instantiation is for a variable, the unqualified-id
      //   in the declaration shall be a template-id.
      Diag(D.getIdentifierLoc(),
           diag::err_explicit_instantiation_without_template_id)
        << PrevTemplate;
      Diag(PrevTemplate->getLocation(),
           diag::note_explicit_instantiation_here);
      return true;
    }

    // Translate the parser's template argument list into our AST format.
    TemplateArgumentListInfo TemplateArgs =
        makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);

    DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
                                        D.getIdentifierLoc(), TemplateArgs);
    if (Res.isInvalid())
      return true;

    if (!Res.isUsable()) {
      // We somehow specified dependent template arguments in an explicit
      // instantiation. This should probably only happen during error
      // recovery.
      Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_dependent);
      return true;
    }

    // Ignore access control bits, we don't need them for redeclaration
    // checking.
    Prev = cast<VarDecl>(Res.get());
  }

  // C++0x [temp.explicit]p2:
  //   If the explicit instantiation is for a member function, a member class
  //   or a static data member of a class template specialization, the name of
  //   the class template specialization in the qualified-id for the member
  //   name shall be a simple-template-id.
  //
  // C++98 has the same restriction, just worded differently.
  //
  // This does not apply to variable template specializations, where the
  // template-id is in the unqualified-id instead.
  if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
    Diag(D.getIdentifierLoc(),
         diag::ext_explicit_instantiation_without_qualified_id)
      << Prev << D.getCXXScopeSpec().getRange();

  CheckExplicitInstantiation(*this, Prev, D.getIdentifierLoc(), true, TSK);

  // Verify that it is okay to explicitly instantiate here.
  TemplateSpecializationKind PrevTSK = Prev->getTemplateSpecializationKind();
  SourceLocation POI = Prev->getPointOfInstantiation();
  bool HasNoEffect = false;
  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
                                             PrevTSK, POI, HasNoEffect))
    return true;

  if (!HasNoEffect) {
    // Instantiate static data member or variable template.
    Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
    // Merge attributes.
    ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes());
    if (TSK == TSK_ExplicitInstantiationDefinition)
      InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
  }

  // Check the new variable specialization against the parsed input.
  if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
    Diag(T->getTypeLoc().getBeginLoc(),
         diag::err_invalid_var_template_spec_type)
        << 0 << PrevTemplate << R << Prev->getType();
    Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
        << 2 << PrevTemplate->getDeclName();
    return true;
  }

  // FIXME: Create an ExplicitInstantiation node?
  return (Decl*) nullptr;
}

// If the declarator is a template-id, translate the parser's template
// argument list into our AST format.
bool HasExplicitTemplateArgs = false;
TemplateArgumentListInfo TemplateArgs;
if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
  TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
  HasExplicitTemplateArgs = true;
}

// C++ [temp.explicit]p1:
//   A [...] function [...] can be explicitly instantiated from its template.
//   A member function [...] of a class template can be explicitly
//  instantiated from the member definition associated with its class
//  template.
UnresolvedSet<8> TemplateMatches;
FunctionDecl *NonTemplateMatch = nullptr;
TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
     P != PEnd; ++P) {
  NamedDecl *Prev = *P;
  if (!HasExplicitTemplateArgs) {
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
      QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
                                              /*AdjustExceptionSpec*/true);
      if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
        if (Method->getPrimaryTemplate()) {
          TemplateMatches.addDecl(Method, P.getAccess());
        } else {
          // FIXME: Can this assert ever happen?  Needs a test.
          assert(!NonTemplateMatch && "Multiple NonTemplateMatches")((void)0);
          NonTemplateMatch = Method;
        }
      }
    }
  }

  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
  if (!FunTmpl)
    continue;

  TemplateDeductionInfo Info(FailedCandidates.getLocation());
  FunctionDecl *Specialization = nullptr;
  if (TemplateDeductionResult TDK
        = DeduceTemplateArguments(FunTmpl,
                             (HasExplicitTemplateArgs ? &TemplateArgs
                                                      : nullptr),
                                  R, Specialization, Info)) {
    // Keep track of almost-matches.
    FailedCandidates.addCandidate()
        .set(P.getPair(), FunTmpl->getTemplatedDecl(),
             MakeDeductionFailureInfo(Context, TDK, Info));
    (void)TDK;
    continue;
  }

  // Target attributes are part of the cuda function signature, so
  // the cuda target of the instantiated function must match that of its
  // template.  Given that C++ template deduction does not take
  // target attributes into account, we reject candidates here that
  // have a different target.
  if (LangOpts.CUDA &&
      IdentifyCUDATarget(Specialization,
                         /* IgnoreImplicitHDAttr = */ true) !=
          IdentifyCUDATarget(D.getDeclSpec().getAttributes())) {
    FailedCandidates.addCandidate().set(
        P.getPair(), FunTmpl->getTemplatedDecl(),
        MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
    continue;
  }

  TemplateMatches.addDecl(Specialization, P.getAccess());
}

FunctionDecl *Specialization = NonTemplateMatch;
if (!Specialization) {
  // Find the most specialized function template specialization.
  UnresolvedSetIterator Result = getMostSpecialized(
      TemplateMatches.begin(), TemplateMatches.end(), FailedCandidates,
      D.getIdentifierLoc(),
      PDiag(diag::err_explicit_instantiation_not_known) << Name,
      PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
      PDiag(diag::note_explicit_instantiation_candidate));

  if (Result == TemplateMatches.end())
    return true;

  // Ignore access control bits, we don't need them for redeclaration checking.
  Specialization = cast<FunctionDecl>(*Result);
}

// C++11 [except.spec]p4
// In an explicit instantiation an exception-specification may be specified,
// but is not required.
// If an exception-specification is specified in an explicit instantiation
// directive, it shall be compatible with the exception-specifications of
// other declarations of that function.
if (auto *FPT = R->getAs<FunctionProtoType>())
  if (FPT->hasExceptionSpec()) {
    unsigned DiagID =
        diag::err_mismatched_exception_spec_explicit_instantiation;
    if (getLangOpts().MicrosoftExt)
      DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
    bool Result = CheckEquivalentExceptionSpec(
        PDiag(DiagID) << Specialization->getType(),
        PDiag(diag::note_explicit_instantiation_here),
        Specialization->getType()->getAs<FunctionProtoType>(),
        Specialization->getLocation(), FPT, D.getBeginLoc());
    // In Microsoft mode, mismatching exception specifications just cause a
    // warning.
    if (!getLangOpts().MicrosoftExt && Result)
      return true;
  }

if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
  Diag(D.getIdentifierLoc(),
       diag::err_explicit_instantiation_member_function_not_instantiated)
    << Specialization
    << (Specialization->getTemplateSpecializationKind() ==
        TSK_ExplicitSpecialization);
  Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
  return true;
}

FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
if (!PrevDecl && Specialization->isThisDeclarationADefinition())
  PrevDecl = Specialization;

if (PrevDecl) {
  bool HasNoEffect = false;
  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
                                             PrevDecl,
                                   PrevDecl->getTemplateSpecializationKind(),
                                        PrevDecl->getPointOfInstantiation(),
                                             HasNoEffect))
    return true;

  // FIXME: We may still want to build some representation of this
  // explicit specialization.
  if (HasNoEffect)
    return (Decl*) nullptr;
}

// HACK: libc++ has a bug where it attempts to explicitly instantiate the
// functions
//     valarray<size_t>::valarray(size_t) and
//     valarray<size_t>::~valarray()
// that it declared to have internal linkage with the internal_linkage
// attribute. Ignore the explicit instantiation declaration in this case.
if (Specialization->hasAttr<InternalLinkageAttr>() &&
    TSK == TSK_ExplicitInstantiationDeclaration) {
  if (auto *RD = dyn_cast<CXXRecordDecl>(Specialization->getDeclContext()))
    if (RD->getIdentifier() && RD->getIdentifier()->isStr("valarray") &&
        RD->isInStdNamespace())
      return (Decl*) nullptr;
}

ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes());

// In MSVC mode, dllimported explicit instantiation definitions are treated as
// instantiation declarations.
if (TSK == TSK_ExplicitInstantiationDefinition &&
    Specialization->hasAttr<DLLImportAttr>() &&
    Context.getTargetInfo().getCXXABI().isMicrosoft())
  TSK = TSK_ExplicitInstantiationDeclaration;

Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());

if (Specialization->isDefined()) {
  // Let the ASTConsumer know that this function has been explicitly
  // instantiated now, and its linkage might have changed.
  Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
} else if (TSK == TSK_ExplicitInstantiationDefinition)
  InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);

// C++0x [temp.explicit]p2:
//   If the explicit instantiation is for a member function, a member class
//   or a static data member of a class template specialization, the name of
//   the class template specialization in the qualified-id for the member
//   name shall be a simple-template-id.
//
// C++98 has the same restriction, just worded differently.
FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
    D.getCXXScopeSpec().isSet() &&
    !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
  Diag(D.getIdentifierLoc(),
       diag::ext_explicit_instantiation_without_qualified_id)
  << Specialization << D.getCXXScopeSpec().getRange();

CheckExplicitInstantiation(
    *this,
    FunTmpl ? (NamedDecl *)FunTmpl
            : Specialization->getInstantiatedFromMemberFunction(),
    D.getIdentifierLoc(), D.getCXXScopeSpec().isSet(), TSK);

// FIXME: Create some kind of ExplicitInstantiationDecl here.
return (Decl*) nullptr;
10338}

10340TypeResult
10341Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                      const CXXScopeSpec &SS, IdentifierInfo *Name,
                      SourceLocation TagLoc, SourceLocation NameLoc) {
// This has to hold, because SS is expected to be defined.
assert(Name && "Expected a name in a dependent tag")((void)0);

NestedNameSpecifier *NNS = SS.getScopeRep();
if (!NNS)
  return true;

TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);

if (TUK == TUK_Declaration || TUK == TUK_Definition) {
  Diag(NameLoc, diag::err_dependent_tag_decl)
    << (TUK == TUK_Definition) << Kind << SS.getRange();
  return true;
}

// Create the resulting type.
ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
QualType Result = Context.getDependentNameType(Kwd, NNS, Name);

// Create type-source location information for this type.
TypeLocBuilder TLB;
DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
TL.setElaboratedKeywordLoc(TagLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));
TL.setNameLoc(NameLoc);
return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
10370}

10372TypeResult
10373Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
                      const CXXScopeSpec &SS, const IdentifierInfo &II,
                      SourceLocation IdLoc) {
if (SS.isInvalid())
  return true;

if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TypenameLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_typename_outside_of_template :
         diag::ext_typename_outside_of_template)
    << FixItHint::CreateRemoval(TypenameLoc);

NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
TypeSourceInfo *TSI = nullptr;
QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
                               TypenameLoc, QualifierLoc, II, IdLoc, &TSI,
                               /*DeducedTSTContext=*/true);
if (T.isNull())
  return true;
return CreateParsedType(T, TSI);
10394}

10396TypeResult
10397Sema::ActOnTypenameType(Scope *S,
                      SourceLocation TypenameLoc,
                      const CXXScopeSpec &SS,
                      SourceLocation TemplateKWLoc,
                      TemplateTy TemplateIn,
                      IdentifierInfo *TemplateII,
                      SourceLocation TemplateIILoc,
                      SourceLocation LAngleLoc,
                      ASTTemplateArgsPtr TemplateArgsIn,
                      SourceLocation RAngleLoc) {
if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TypenameLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_typename_outside_of_template :
         diag::ext_typename_outside_of_template)
    << FixItHint::CreateRemoval(TypenameLoc);

// Strangely, non-type results are not ignored by this lookup, so the
// program is ill-formed if it finds an injected-class-name.
if (TypenameLoc.isValid()) {
  auto *LookupRD =
      dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
    Diag(TemplateIILoc,
         diag::ext_out_of_line_qualified_id_type_names_constructor)
      << TemplateII << 0 /*injected-class-name used as template name*/
      << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
  }
}

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

TemplateName Template = TemplateIn.get();
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  // Construct a dependent template specialization type.
  assert(DTN && "dependent template has non-dependent name?")((void)0);
  assert(DTN->getQualifier() == SS.getScopeRep())((void)0);
  QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                              TemplateArgs);

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

QualType T = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
if (T.isNull())
  return true;

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

T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
TL.setElaboratedKeywordLoc(TypenameLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));

TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
return CreateParsedType(T, TSI);
10478}


10481/// Determine whether this failed name lookup should be treated as being
10482/// disabled by a usage of std::enable_if.
10483static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
                     SourceRange &CondRange, Expr *&Cond) {
// We must be looking for a ::type...
if (!II.isStr("type"))
  return false;

// ... within an explicitly-written template specialization...
if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
  return false;
TypeLoc EnableIfTy = NNS.getTypeLoc();
TemplateSpecializationTypeLoc EnableIfTSTLoc =
    EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
  return false;
const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.getTypePtr();

// ... which names a complete class template declaration...
const TemplateDecl *EnableIfDecl =
  EnableIfTST->getTemplateName().getAsTemplateDecl();
if (!EnableIfDecl || EnableIfTST->isIncompleteType())
  return false;

// ... called "enable_if".
const IdentifierInfo *EnableIfII =
  EnableIfDecl->getDeclName().getAsIdentifierInfo();
if (!EnableIfII || !EnableIfII->isStr("enable_if"))
  return false;

// Assume the first template argument is the condition.
CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();

// Dig out the condition.
Cond = nullptr;
if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
      != TemplateArgument::Expression)
  return true;

Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();

// Ignore Boolean literals; they add no value.
if (isa<CXXBoolLiteralExpr>(Cond->IgnoreParenCasts()))
  Cond = nullptr;

return true;
10527}

10529QualType
10530Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
                      SourceLocation KeywordLoc,
                      NestedNameSpecifierLoc QualifierLoc,
                      const IdentifierInfo &II,
                      SourceLocation IILoc,
                      TypeSourceInfo **TSI,
                      bool DeducedTSTContext) {
QualType T = CheckTypenameType(Keyword, KeywordLoc, QualifierLoc, II, IILoc,
                               DeducedTSTContext);
if (T.isNull())
  return QualType();

*TSI = Context.CreateTypeSourceInfo(T);
if (isa<DependentNameType>(T)) {
  DependentNameTypeLoc TL =
      (*TSI)->getTypeLoc().castAs<DependentNameTypeLoc>();
  TL.setElaboratedKeywordLoc(KeywordLoc);
  TL.setQualifierLoc(QualifierLoc);
  TL.setNameLoc(IILoc);
} else {
  ElaboratedTypeLoc TL = (*TSI)->getTypeLoc().castAs<ElaboratedTypeLoc>();
  TL.setElaboratedKeywordLoc(KeywordLoc);
  TL.setQualifierLoc(QualifierLoc);
  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IILoc);
}
return T;
10556}

10558/// Build the type that describes a C++ typename specifier,
10559/// e.g., "typename T::type".
10560QualType
10561Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
                      SourceLocation KeywordLoc,
                      NestedNameSpecifierLoc QualifierLoc,
                      const IdentifierInfo &II,
                      SourceLocation IILoc, bool DeducedTSTContext) {
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

DeclContext *Ctx = nullptr;
if (QualifierLoc) {
  Ctx = computeDeclContext(SS);
  if (!Ctx) {
    // If the nested-name-specifier is dependent and couldn't be
    // resolved to a type, build a typename type.
    assert(QualifierLoc.getNestedNameSpecifier()->isDependent())((void)0);
    return Context.getDependentNameType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                        &II);
  }

  // If the nested-name-specifier refers to the current instantiation,
  // the "typename" keyword itself is superfluous. In C++03, the
  // program is actually ill-formed. However, DR 382 (in C++0x CD1)
  // allows such extraneous "typename" keywords, and we retroactively
  // apply this DR to C++03 code with only a warning. In any case we continue.

  if (RequireCompleteDeclContext(SS, Ctx))
    return QualType();
}

DeclarationName Name(&II);
LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
if (Ctx)
  LookupQualifiedName(Result, Ctx, SS);
else
  LookupName(Result, CurScope);
unsigned DiagID = 0;
Decl *Referenced = nullptr;
switch (Result.getResultKind()) {
case LookupResult::NotFound: {
  // If we're looking up 'type' within a template named 'enable_if', produce
  // a more specific diagnostic.
  SourceRange CondRange;
  Expr *Cond = nullptr;
  if (Ctx && isEnableIf(QualifierLoc, II, CondRange, Cond)) {
    // If we have a condition, narrow it down to the specific failed
    // condition.
    if (Cond) {
      Expr *FailedCond;
      std::string FailedDescription;
      std::tie(FailedCond, FailedDescription) =
        findFailedBooleanCondition(Cond);

      Diag(FailedCond->getExprLoc(),
           diag::err_typename_nested_not_found_requirement)
        << FailedDescription
        << FailedCond->getSourceRange();
      return QualType();
    }

    Diag(CondRange.getBegin(),
         diag::err_typename_nested_not_found_enable_if)
        << Ctx << CondRange;
    return QualType();
  }

  DiagID = Ctx ? diag::err_typename_nested_not_found
               : diag::err_unknown_typename;
  break;
}

case LookupResult::FoundUnresolvedValue: {
  // We found a using declaration that is a value. Most likely, the using
  // declaration itself is meant to have the 'typename' keyword.
  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
                        IILoc);
  Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
    << Name << Ctx << FullRange;
  if (UnresolvedUsingValueDecl *Using
        = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
    SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
    Diag(Loc, diag::note_using_value_decl_missing_typename)
      << FixItHint::CreateInsertion(Loc, "typename ");
  }
}
// Fall through to create a dependent typename type, from which we can recover
// better.
LLVM_FALLTHROUGH[[gnu::fallthrough]];

case LookupResult::NotFoundInCurrentInstantiation:
  // Okay, it's a member of an unknown instantiation.
  return Context.getDependentNameType(Keyword,
                                      QualifierLoc.getNestedNameSpecifier(),
                                      &II);

case LookupResult::Found:
  if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
    // C++ [class.qual]p2:
    //   In a lookup in which function names are not ignored and the
    //   nested-name-specifier nominates a class C, if the name specified
    //   after the nested-name-specifier, when looked up in C, is the
    //   injected-class-name of C [...] then the name is instead considered
    //   to name the constructor of class C.
    //
    // Unlike in an elaborated-type-specifier, function names are not ignored
    // in typename-specifier lookup. However, they are ignored in all the
    // contexts where we form a typename type with no keyword (that is, in
    // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
    //
    // FIXME: That's not strictly true: mem-initializer-id lookup does not
    // ignore functions, but that appears to be an oversight.
    auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
    auto *FoundRD = dyn_cast<CXXRecordDecl>(Type);
    if (Keyword == ETK_Typename && LookupRD && FoundRD &&
        FoundRD->isInjectedClassName() &&
        declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
      Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
          << &II << 1 << 0 /*'typename' keyword used*/;

    // We found a type. Build an ElaboratedType, since the
    // typename-specifier was just sugar.
    MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
    return Context.getElaboratedType(Keyword,
                                     QualifierLoc.getNestedNameSpecifier(),
                                     Context.getTypeDeclType(Type));
  }

  // C++ [dcl.type.simple]p2:
  //   A type-specifier of the form
  //     typename[opt] nested-name-specifier[opt] template-name
  //   is a placeholder for a deduced class type [...].
  if (getLangOpts().CPlusPlus17) {
    if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {
      if (!DeducedTSTContext) {
        QualType T(QualifierLoc
                       ? QualifierLoc.getNestedNameSpecifier()->getAsType()
                       : nullptr, 0);
        if (!T.isNull())
          Diag(IILoc, diag::err_dependent_deduced_tst)
            << (int)getTemplateNameKindForDiagnostics(TemplateName(TD)) << T;
        else
          Diag(IILoc, diag::err_deduced_tst)
            << (int)getTemplateNameKindForDiagnostics(TemplateName(TD));
        Diag(TD->getLocation(), diag::note_template_decl_here);
        return QualType();
      }
      return Context.getElaboratedType(
          Keyword, QualifierLoc.getNestedNameSpecifier(),
          Context.getDeducedTemplateSpecializationType(TemplateName(TD),
                                                       QualType(), false));
    }
  }

  DiagID = Ctx ? diag::err_typename_nested_not_type
               : diag::err_typename_not_type;
  Referenced = Result.getFoundDecl();
  break;

case LookupResult::FoundOverloaded:
  DiagID = Ctx ? diag::err_typename_nested_not_type
               : diag::err_typename_not_type;
  Referenced = *Result.begin();
  break;

case LookupResult::Ambiguous:
  return QualType();
}

// If we get here, it's because name lookup did not find a
// type. Emit an appropriate diagnostic and return an error.
SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
                      IILoc);
if (Ctx)
  Diag(IILoc, DiagID) << FullRange << Name << Ctx;
else
  Diag(IILoc, DiagID) << FullRange << Name;
if (Referenced)
  Diag(Referenced->getLocation(),
       Ctx ? diag::note_typename_member_refers_here
           : diag::note_typename_refers_here)
    << Name;
return QualType();
10743}

10745namespace {
// See Sema::RebuildTypeInCurrentInstantiation
class CurrentInstantiationRebuilder
  : public TreeTransform<CurrentInstantiationRebuilder> {
  SourceLocation Loc;
  DeclarationName Entity;

public:
  typedef TreeTransform<CurrentInstantiationRebuilder> inherited;

  CurrentInstantiationRebuilder(Sema &SemaRef,
                                SourceLocation Loc,
                                DeclarationName Entity)
  : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
    Loc(Loc), Entity(Entity) { }

  /// Determine whether the given type \p T has already been
  /// transformed.
  ///
  /// For the purposes of type reconstruction, a type has already been
  /// transformed if it is NULL or if it is not dependent.
  bool AlreadyTransformed(QualType T) {
    return T.isNull() || !T->isInstantiationDependentType();
  }

  /// Returns the location of the entity whose type is being
  /// rebuilt.
  SourceLocation getBaseLocation() { return Loc; }

  /// Returns the name of the entity whose type is being rebuilt.
  DeclarationName getBaseEntity() { return Entity; }

  /// Sets the "base" location and entity when that
  /// information is known based on another transformation.
  void setBase(SourceLocation Loc, DeclarationName Entity) {
    this->Loc = Loc;
    this->Entity = Entity;
  }

  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    // Lambdas never need to be transformed.
    return E;
  }
};
10789} // end anonymous namespace

10791/// Rebuilds a type within the context of the current instantiation.
10792///
10793/// The type \p T is part of the type of an out-of-line member definition of
10794/// a class template (or class template partial specialization) that was parsed
10795/// and constructed before we entered the scope of the class template (or
10796/// partial specialization thereof). This routine will rebuild that type now
10797/// that we have entered the declarator's scope, which may produce different
10798/// canonical types, e.g.,
10799///
10800/// \code
10801/// template<typename T>
10802/// struct X {
10803///   typedef T* pointer;
10804///   pointer data();
10805/// };
10806///
10807/// template<typename T>
10808/// typename X<T>::pointer X<T>::data() { ... }
10809/// \endcode
10810///
10811/// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
10812/// since we do not know that we can look into X<T> when we parsed the type.
10813/// This function will rebuild the type, performing the lookup of "pointer"
10814/// in X<T> and returning an ElaboratedType whose canonical type is the same
10815/// as the canonical type of T*, allowing the return types of the out-of-line
10816/// definition and the declaration to match.
10817TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
                                                      SourceLocation Loc,
                                                      DeclarationName Name) {
if (!T || !T->getType()->isInstantiationDependentType())
  return T;

CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
return Rebuilder.TransformType(T);
10825}

10827ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) {
CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
                                        DeclarationName());
return Rebuilder.TransformExpr(E);
10831}

10833bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) {
if (SS.isInvalid())
  return true;

NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
                                        DeclarationName());
NestedNameSpecifierLoc Rebuilt
  = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
if (!Rebuilt)
  return true;

SS.Adopt(Rebuilt);
return false;
10847}

10849/// Rebuild the template parameters now that we know we're in a current
10850/// instantiation.
10851bool Sema::RebuildTemplateParamsInCurrentInstantiation(
                                             TemplateParameterList *Params) {
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  Decl *Param = Params->getParam(I);

  // There is nothing to rebuild in a type parameter.
  if (isa<TemplateTypeParmDecl>(Param))
    continue;

  // Rebuild the template parameter list of a template template parameter.
  if (TemplateTemplateParmDecl *TTP
      = dyn_cast<TemplateTemplateParmDecl>(Param)) {
    if (RebuildTemplateParamsInCurrentInstantiation(
          TTP->getTemplateParameters()))
      return true;

    continue;
  }

  // Rebuild the type of a non-type template parameter.
  NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
  TypeSourceInfo *NewTSI
    = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
                                        NTTP->getLocation(),
                                        NTTP->getDeclName());
  if (!NewTSI)
    return true;

  if (NewTSI->getType()->isUndeducedType()) {
    // C++17 [temp.dep.expr]p3:
    //   An id-expression is type-dependent if it contains
    //    - an identifier associated by name lookup with a non-type
    //      template-parameter declared with a type that contains a
    //      placeholder type (7.1.7.4),
    NewTSI = SubstAutoTypeSourceInfo(NewTSI, Context.DependentTy);
  }

  if (NewTSI != NTTP->getTypeSourceInfo()) {
    NTTP->setTypeSourceInfo(NewTSI);
    NTTP->setType(NewTSI->getType());
  }
}

return false;
10895}

10897/// Produces a formatted string that describes the binding of
10898/// template parameters to template arguments.
10899std::string
10900Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                    const TemplateArgumentList &Args) {
return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
10903}

10905std::string
10906Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                    const TemplateArgument *Args,
                                    unsigned NumArgs) {
SmallString<128> Str;
llvm::raw_svector_ostream Out(Str);

if (!Params || Params->size() == 0 || NumArgs == 0)
  return std::string();

for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  if (I >= NumArgs)
    break;

  if (I == 0)
    Out << "[with ";
  else
    Out << ", ";

  if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
    Out << Id->getName();
  } else {
    Out << '$' << I;
  }

  Out << " = ";
  Args[I].print(
      getPrintingPolicy(), Out,
      TemplateParameterList::shouldIncludeTypeForArgument(Params, I));
}

Out << ']';
return std::string(Out.str());
10938}

10940void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
                                  CachedTokens &Toks) {
if (!FD)
  return;

auto LPT = std::make_unique<LateParsedTemplate>();

// Take tokens to avoid allocations
LPT->Toks.swap(Toks);
LPT->D = FnD;
LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));

FD->setLateTemplateParsed(true);
10953}

10955void Sema::UnmarkAsLateParsedTemplate(FunctionDecl *FD) {
if (!FD)
  return;
FD->setLateTemplateParsed(false);
10959}

10961bool Sema::IsInsideALocalClassWithinATemplateFunction() {
DeclContext *DC = CurContext;

while (DC) {
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
    const FunctionDecl *FD = RD->isLocalClass();
    return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
  } else if (DC->isTranslationUnit() || DC->isNamespace())
    return false;

  DC = DC->getParent();
}
return false;
10974}

10976namespace {
10977/// Walk the path from which a declaration was instantiated, and check
10978/// that every explicit specialization along that path is visible. This enforces
10979/// C++ [temp.expl.spec]/6:
10980///
10981///   If a template, a member template or a member of a class template is
10982///   explicitly specialized then that specialization shall be declared before
10983///   the first use of that specialization that would cause an implicit
10984///   instantiation to take place, in every translation unit in which such a
10985///   use occurs; no diagnostic is required.
10986///
10987/// and also C++ [temp.class.spec]/1:
10988///
10989///   A partial specialization shall be declared before the first use of a
10990///   class template specialization that would make use of the partial
10991///   specialization as the result of an implicit or explicit instantiation
10992///   in every translation unit in which such a use occurs; no diagnostic is
10993///   required.
10994class ExplicitSpecializationVisibilityChecker {
Sema &S;
SourceLocation Loc;
llvm::SmallVector<Module *, 8> Modules;

10999public:
ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
    : S(S), Loc(Loc) {}

void check(NamedDecl *ND) {
  if (auto *FD = dyn_cast<FunctionDecl>(ND))
    return checkImpl(FD);
  if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
    return checkImpl(RD);
  if (auto *VD = dyn_cast<VarDecl>(ND))
    return checkImpl(VD);
  if (auto *ED = dyn_cast<EnumDecl>(ND))
    return checkImpl(ED);
}

11014private:
void diagnose(NamedDecl *D, bool IsPartialSpec) {
  auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
                            : Sema::MissingImportKind::ExplicitSpecialization;
  const bool Recover = true;

  // If we got a custom set of modules (because only a subset of the
  // declarations are interesting), use them, otherwise let
  // diagnoseMissingImport intelligently pick some.
  if (Modules.empty())
    S.diagnoseMissingImport(Loc, D, Kind, Recover);
  else
    S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
}

// Check a specific declaration. There are three problematic cases:
//
//  1) The declaration is an explicit specialization of a template
//     specialization.
//  2) The declaration is an explicit specialization of a member of an
//     templated class.
//  3) The declaration is an instantiation of a template, and that template
//     is an explicit specialization of a member of a templated class.
//
// We don't need to go any deeper than that, as the instantiation of the
// surrounding class / etc is not triggered by whatever triggered this
// instantiation, and thus should be checked elsewhere.
template<typename SpecDecl>
void checkImpl(SpecDecl *Spec) {
  bool IsHiddenExplicitSpecialization = false;
  if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
    IsHiddenExplicitSpecialization =
        Spec->getMemberSpecializationInfo()
            ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
            : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
  } else {
    checkInstantiated(Spec);
  }

  if (IsHiddenExplicitSpecialization)
    diagnose(Spec->getMostRecentDecl(), false);
}

void checkInstantiated(FunctionDecl *FD) {
  if (auto *TD = FD->getPrimaryTemplate())
    checkTemplate(TD);
}

void checkInstantiated(CXXRecordDecl *RD) {
  auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
  if (!SD)
    return;

  auto From = SD->getSpecializedTemplateOrPartial();
  if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
    checkTemplate(TD);
  else if (auto *TD =
               From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
    if (!S.hasVisibleDeclaration(TD))
      diagnose(TD, true);
    checkTemplate(TD);
  }
}

void checkInstantiated(VarDecl *RD) {
  auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
  if (!SD)
    return;

  auto From = SD->getSpecializedTemplateOrPartial();
  if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
    checkTemplate(TD);
  else if (auto *TD =
               From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
    if (!S.hasVisibleDeclaration(TD))
      diagnose(TD, true);
    checkTemplate(TD);
  }
}

void checkInstantiated(EnumDecl *FD) {}

template<typename TemplDecl>
void checkTemplate(TemplDecl *TD) {
  if (TD->isMemberSpecialization()) {
    if (!S.hasVisibleMemberSpecialization(TD, &Modules))
      diagnose(TD->getMostRecentDecl(), false);
  }
}
11103};
11104} // end anonymous namespace

11106void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
if (!getLangOpts().Modules)
  return;

ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
11111}

←

/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; }
30
←
Assuming the condition is false→
31
←
Returning zero, which participates in a condition later→
/// A scope specifier is present, but may be valid or invalid.
bool isNotEmpty() const { return !isEmpty(); }
29
←
Calling 'CXXScopeSpec::isEmpty'→
32
←
Returning from 'CXXScopeSpec::isEmpty'→
33
←
Returning the value 1, which participates in a condition later→

/// An error occurred during parsing of the scope specifier.
bool isInvalid() const { return Range.isValid() && getScopeRep() == nullptr; }
9
←
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; }

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

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/AST/Type.h

→

1//===- Type.h - C Language Family Type Representation -----------*- 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/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H

20#include "clang/AST/DependenceFlags.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.h"
24#include "clang/Basic/AttrKinds.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/ExceptionSpecificationType.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Basic/Visibility.h"
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/Twine.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include "llvm/Support/type_traits.h"
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <cstring>
54#include <string>
55#include <type_traits>
56#include <utility>

58namespace clang {

60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;

67enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
70};

72namespace serialization {
template <class T> class AbstractTypeReader;
template <class T> class AbstractTypeWriter;
75}

77} // namespace clang

79namespace llvm {

template <typename T>
struct PointerLikeTypeTraits;
template<>
struct PointerLikeTypeTraits< ::clang::Type*> {
  static inline void *getAsVoidPointer(::clang::Type *P) { return P; }

  static inline ::clang::Type *getFromVoidPointer(void *P) {
    return static_cast< ::clang::Type*>(P);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

template<>
struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
  static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }

  static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
    return static_cast< ::clang::ExtQuals*>(P);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

105} // namespace llvm

107namespace clang {

109class ASTContext;
110template <typename> class CanQual;
111class CXXRecordDecl;
112class DeclContext;
113class EnumDecl;
114class Expr;
115class ExtQualsTypeCommonBase;
116class FunctionDecl;
117class IdentifierInfo;
118class NamedDecl;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
123class RecordDecl;
124class Stmt;
125class TagDecl;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;

133using CanQualType = CanQual<Type>;

135// Provide forward declarations for all of the *Type classes.
136#define TYPE(Class, Base) class Class##Type;
137#include "clang/AST/TypeNodes.inc"

139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
  Const    = 0x1,
  Restrict = 0x2,
  Volatile = 0x4,
  CVRMask = Const | Volatile | Restrict
};

enum GC {
  GCNone = 0,
  Weak,
  Strong
};

enum ObjCLifetime {
  /// There is no lifetime qualification on this type.
  OCL_None,

  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,

  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,

  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,

  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing
};

enum {
  /// The maximum supported address space number.
  /// 23 bits should be enough for anyone.
  MaxAddressSpace = 0x7fffffu,

  /// The width of the "fast" qualifier mask.
  FastWidth = 3,

  /// The fast qualifier mask.
  FastMask = (1 << FastWidth) - 1
};

/// Returns the common set of qualifiers while removing them from
/// the given sets.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
  // If both are only CVR-qualified, bit operations are sufficient.
  if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
    Qualifiers Q;
    Q.Mask = L.Mask & R.Mask;
    L.Mask &= ~Q.Mask;
    R.Mask &= ~Q.Mask;
    return Q;
  }

  Qualifiers Q;
  unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
  Q.addCVRQualifiers(CommonCRV);
  L.removeCVRQualifiers(CommonCRV);
  R.removeCVRQualifiers(CommonCRV);

  if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
    Q.setObjCGCAttr(L.getObjCGCAttr());
    L.removeObjCGCAttr();
    R.removeObjCGCAttr();
  }

  if (L.getObjCLifetime() == R.getObjCLifetime()) {
    Q.setObjCLifetime(L.getObjCLifetime());
    L.removeObjCLifetime();
    R.removeObjCLifetime();
  }

  if (L.getAddressSpace() == R.getAddressSpace()) {
    Q.setAddressSpace(L.getAddressSpace());
    L.removeAddressSpace();
    R.removeAddressSpace();
  }
  return Q;
}

static Qualifiers fromFastMask(unsigned Mask) {
  Qualifiers Qs;
  Qs.addFastQualifiers(Mask);
  return Qs;
}

static Qualifiers fromCVRMask(unsigned CVR) {
  Qualifiers Qs;
  Qs.addCVRQualifiers(CVR);
  return Qs;
}

static Qualifiers fromCVRUMask(unsigned CVRU) {
  Qualifiers Qs;
  Qs.addCVRUQualifiers(CVRU);
  return Qs;
}

// Deserialize qualifiers from an opaque representation.
static Qualifiers fromOpaqueValue(unsigned opaque) {
  Qualifiers Qs;
  Qs.Mask = opaque;
  return Qs;
}

// Serialize these qualifiers into an opaque representation.
unsigned getAsOpaqueValue() const {
  return Mask;
}

bool hasConst() const { return Mask & Const; }
bool hasOnlyConst() const { return Mask == Const; }
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
bool hasOnlyVolatile() const { return Mask == Volatile; }
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
bool hasOnlyRestrict() const { return Mask == Restrict; }
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }

void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((void)0);
  Mask |= mask;
}

bool hasUnaligned() const { return Mask & UMask; }
void setUnaligned(bool flag) {
  Mask = (Mask & ~UMask) | (flag ? UMask : 0);
}
void removeUnaligned() { Mask &= ~UMask; }
void addUnaligned() { Mask |= UMask; }

bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
void setObjCGCAttr(GC type) {
  Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
}
void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
void addObjCGCAttr(GC type) {
  assert(type)((void)0);
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  return qs;
}
Qualifiers withoutAddressSpace() const {
  Qualifiers qs = *this;
  qs.removeAddressSpace();
  return qs;
}

bool hasObjCLifetime() const { return Mask & LifetimeMask; }
ObjCLifetime getObjCLifetime() const {
  return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
}
void setObjCLifetime(ObjCLifetime type) {
  Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
}
void removeObjCLifetime() { setObjCLifetime(OCL_None); }
void addObjCLifetime(ObjCLifetime type) {
  assert(type)((void)0);
  assert(!hasObjCLifetime())((void)0);
  Mask |= (type << LifetimeShift);
}

/// True if the lifetime is neither None or ExplicitNone.
bool hasNonTrivialObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime > OCL_ExplicitNone);
}

/// True if the lifetime is either strong or weak.
bool hasStrongOrWeakObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime == OCL_Strong || lifetime == OCL_Weak);
}

bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
LangAS getAddressSpace() const {
  return static_cast<LangAS>(Mask >> AddressSpaceShift);
}
bool hasTargetSpecificAddressSpace() const {
  return isTargetAddressSpace(getAddressSpace());
}
/// Get the address space attribute value to be printed by diagnostics.
unsigned getAddressSpaceAttributePrintValue() const {
  auto Addr = getAddressSpace();
  // This function is not supposed to be used with language specific
  // address spaces. If that happens, the diagnostic message should consider
  // printing the QualType instead of the address space value.
  assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((void)0);
  if (Addr != LangAS::Default)
    return toTargetAddressSpace(Addr);
  // TODO: The diagnostic messages where Addr may be 0 should be fixed
  // since it cannot differentiate the situation where 0 denotes the default
  // address space or user specified __attribute__((address_space(0))).
  return 0;
}
void setAddressSpace(LangAS space) {
  assert((unsigned)space <= MaxAddressSpace)((void)0);
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((void)0);
  setAddressSpace(space);
}

// Fast qualifiers are those that can be allocated directly
// on a QualType object.
bool hasFastQualifiers() const { return getFastQualifiers(); }
unsigned getFastQualifiers() const { return Mask & FastMask; }
void setFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask |= mask;
}

/// Return true if the set contains any qualifiers which require an ExtQuals
/// node to be allocated.
bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
Qualifiers getNonFastQualifiers() const {
  Qualifiers Quals = *this;
  Quals.setFastQualifiers(0);
  return Quals;
}

/// Return true if the set contains any qualifiers.
bool hasQualifiers() const { return Mask; }
bool empty() const { return !Mask; }

/// Add the qualifiers from the given set to this set.
void addQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-or it in.
  if (!(Q.Mask & ~CVRMask))
    Mask |= Q.Mask;
  else {
    Mask |= (Q.Mask & CVRMask);
    if (Q.hasAddressSpace())
      addAddressSpace(Q.getAddressSpace());
    if (Q.hasObjCGCAttr())
      addObjCGCAttr(Q.getObjCGCAttr());
    if (Q.hasObjCLifetime())
      addObjCLifetime(Q.getObjCLifetime());
  }
}

/// Remove the qualifiers from the given set from this set.
void removeQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-and the inverse in.
  if (!(Q.Mask & ~CVRMask))
    Mask &= ~Q.Mask;
  else {
    Mask &= ~(Q.Mask & CVRMask);
    if (getObjCGCAttr() == Q.getObjCGCAttr())
      removeObjCGCAttr();
    if (getObjCLifetime() == Q.getObjCLifetime())
      removeObjCLifetime();
    if (getAddressSpace() == Q.getAddressSpace())
      removeAddressSpace();
  }
}

/// Add the qualifiers from the given set to this set, given that
/// they don't conflict.
void addConsistentQualifiers(Qualifiers qs) {
  assert(getAddressSpace() == qs.getAddressSpace() ||((void)0)
         !hasAddressSpace() || !qs.hasAddressSpace())((void)0);
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((void)0)
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((void)0);
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((void)0)
         !hasObjCLifetime() || !qs.hasObjCLifetime())((void)0);
  Mask |= qs.Mask;
}

/// Returns true if address space A is equal to or a superset of B.
/// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
/// overlapping address spaces.
/// CL1.1 or CL1.2:
///   every address space is a superset of itself.
/// CL2.0 adds:
///   __generic is a superset of any address space except for __constant.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
  // Address spaces must match exactly.
  return A == B ||
         // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
         // for __constant can be used as __generic.
         (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
         // We also define global_device and global_host address spaces,
         // to distinguish global pointers allocated on host from pointers
         // allocated on device, which are a subset of __global.
         (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
                                         B == LangAS::opencl_global_host)) ||
         (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
                                       B == LangAS::sycl_global_host)) ||
         // Consider pointer size address spaces to be equivalent to default.
         ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
          (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
         // Default is a superset of SYCL address spaces.
         (A == LangAS::Default &&
          (B == LangAS::sycl_private || B == LangAS::sycl_local ||
           B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
           B == LangAS::sycl_global_host));
}

/// Returns true if the address space in these qualifiers is equal to or
/// a superset of the address space in the argument qualifiers.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
}

/// Determines if these qualifiers compatibly include another set.
/// Generally this answers the question of whether an object with the other
/// qualifiers can be safely used as an object with these qualifiers.
bool compatiblyIncludes(Qualifiers other) const {
  return isAddressSpaceSupersetOf(other) &&
         // ObjC GC qualifiers can match, be added, or be removed, but can't
         // be changed.
         (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
          !other.hasObjCGCAttr()) &&
         // ObjC lifetime qualifiers must match exactly.
         getObjCLifetime() == other.getObjCLifetime() &&
         // CVR qualifiers may subset.
         (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
         // U qualifier may superset.
         (!other.hasUnaligned() || hasUnaligned());
}

/// Determines if these qualifiers compatibly include another set of
/// qualifiers from the narrow perspective of Objective-C ARC lifetime.
///
/// One set of Objective-C lifetime qualifiers compatibly includes the other
/// if the lifetime qualifiers match, or if both are non-__weak and the
/// including set also contains the 'const' qualifier, or both are non-__weak
/// and one is None (which can only happen in non-ARC modes).
bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
  if (getObjCLifetime() == other.getObjCLifetime())
    return true;

  if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
    return false;

  if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
    return true;

  return hasConst();
}

/// Determine whether this set of qualifiers is a strict superset of
/// another set of qualifiers, not considering qualifier compatibility.
bool isStrictSupersetOf(Qualifiers Other) const;

bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }

explicit operator bool() const { return hasQualifiers(); }

Qualifiers &operator+=(Qualifiers R) {
  addQualifiers(R);
  return *this;
}

// Union two qualifier sets.  If an enumerated qualifier appears
// in both sets, use the one from the right.
friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
  L += R;
  return L;
}

Qualifiers &operator-=(Qualifiers R) {
  removeQualifiers(R);
  return *this;
}

/// Compute the difference between two qualifier sets.
friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
  L -= R;
  return L;
}

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

static std::string getAddrSpaceAsString(LangAS AS);

bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
void print(raw_ostream &OS, const PrintingPolicy &Policy,
           bool appendSpaceIfNonEmpty = false) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddInteger(Mask);
}

589private:
// bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
//           |C R V|U|GCAttr|Lifetime|AddressSpace|
uint32_t Mask = 0;

static const uint32_t UMask = 0x8;
static const uint32_t UShift = 3;
static const uint32_t GCAttrMask = 0x30;
static const uint32_t GCAttrShift = 4;
static const uint32_t LifetimeMask = 0x1C0;
static const uint32_t LifetimeShift = 6;
static const uint32_t AddressSpaceMask =
    ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
static const uint32_t AddressSpaceShift = 9;
603};

605/// A std::pair-like structure for storing a qualified type split
606/// into its local qualifiers and its locally-unqualified type.
607struct SplitQualType {
/// The locally-unqualified type.
const Type *Ty = nullptr;

/// The local qualifiers.
Qualifiers Quals;

SplitQualType() = default;
SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}

SplitQualType getSingleStepDesugaredType() const; // end of this file

// Make std::tie work.
std::pair<const Type *,Qualifiers> asPair() const {
  return std::pair<const Type *, Qualifiers>(Ty, Quals);
}

friend bool operator==(SplitQualType a, SplitQualType b) {
  return a.Ty == b.Ty && a.Quals == b.Quals;
}
friend bool operator!=(SplitQualType a, SplitQualType b) {
  return a.Ty != b.Ty || a.Quals != b.Quals;
}
630};

632/// The kind of type we are substituting Objective-C type arguments into.
633///
634/// The kind of substitution affects the replacement of type parameters when
635/// no concrete type information is provided, e.g., when dealing with an
636/// unspecialized type.
637enum class ObjCSubstitutionContext {
/// An ordinary type.
Ordinary,

/// The result type of a method or function.
Result,

/// The parameter type of a method or function.
Parameter,

/// The type of a property.
Property,

/// The superclass of a type.
Superclass,
652};

654/// A (possibly-)qualified type.
655///
656/// For efficiency, we don't store CV-qualified types as nodes on their
657/// own: instead each reference to a type stores the qualifiers.  This
658/// greatly reduces the number of nodes we need to allocate for types (for
659/// example we only need one for 'int', 'const int', 'volatile int',
660/// 'const volatile int', etc).
661///
662/// As an added efficiency bonus, instead of making this a pair, we
663/// just store the two bits we care about in the low bits of the
664/// pointer.  To handle the packing/unpacking, we make QualType be a
665/// simple wrapper class that acts like a smart pointer.  A third bit
666/// indicates whether there are extended qualifiers present, in which
667/// case the pointer points to a special structure.
668class QualType {
friend class QualifierCollector;

// Thankfully, these are efficiently composable.
llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
                     Qualifiers::FastWidth> Value;

const ExtQuals *getExtQualsUnsafe() const {
  return Value.getPointer().get<const ExtQuals*>();
}

const Type *getTypePtrUnsafe() const {
  return Value.getPointer().get<const Type*>();
}

const ExtQualsTypeCommonBase *getCommonPtr() const {
  assert(!isNull() && "Cannot retrieve a NULL type pointer")((void)0);
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

690public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }

/// Retrieves a pointer to the underlying (unqualified) type.
///
/// This function requires that the type not be NULL. If the type might be
/// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
const Type *getTypePtr() const;

const Type *getTypePtrOrNull() const;

/// Retrieves a pointer to the name of the base type.
const IdentifierInfo *getBaseTypeIdentifier() const;

/// Divides a QualType into its unqualified type and a set of local
/// qualifiers.
SplitQualType split() const;

void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }

static QualType getFromOpaquePtr(const void *Ptr) {
  QualType T;
  T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
  return T;
}

const Type &operator*() const {
  return *getTypePtr();
}

const Type *operator->() const {
  return getTypePtr();
}

bool isCanonical() const;
bool isCanonicalAsParam() const;

/// Return true if this QualType doesn't point to a type yet.
bool isNull() const {
  return Value.getPointer().isNull();
13
←
Calling 'PointerUnion::isNull'→
24
←
Returning from 'PointerUnion::isNull'→
25
←
Returning the value 1, which participates in a condition later→
}

/// Determine whether this particular QualType instance has the
/// "const" qualifier set, without looking through typedefs that may have
/// added "const" at a different level.
bool isLocalConstQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Const);
}

/// Determine whether this type is const-qualified.
bool isConstQualified() const;

/// Determine whether this particular QualType instance has the
/// "restrict" qualifier set, without looking through typedefs that may have
/// added "restrict" at a different level.
bool isLocalRestrictQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Restrict);
}

/// Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// Determine whether this particular QualType instance has the
/// "volatile" qualifier set, without looking through typedefs that may have
/// added "volatile" at a different level.
bool isLocalVolatileQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Volatile);
}

/// Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// Determine whether this particular QualType instance has any
/// qualifiers, without looking through any typedefs that might add
/// qualifiers at a different level.
bool hasLocalQualifiers() const {
  return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
}

/// Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// Determine whether this particular QualType instance has any
/// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
/// instance.
bool hasLocalNonFastQualifiers() const {
  return Value.getPointer().is<const ExtQuals*>();
}

/// Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// local to this particular QualType instance, not including any qualifiers
/// acquired through typedefs or other sugar.
unsigned getLocalCVRQualifiers() const {
  return getLocalFastQualifiers();
}

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// applied to this type.
unsigned getCVRQualifiers() const;

bool isConstant(const ASTContext& Ctx) const {
  return QualType::isConstant(*this, Ctx);
}

/// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isPODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the rules of the C++98
/// standard, regardless of the current compilation's language.
bool isCXX98PODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the more relaxed rules
/// of the C++11 standard, regardless of the current compilation's language.
/// (C++0x [basic.types]p9). Note that, unlike
/// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
bool isCXX11PODType(const ASTContext &Context) const;

/// Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isTrivialType(const ASTContext &Context) const;

/// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTriviallyCopyableType(const ASTContext &Context) const;


/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;

/// Returns true if it is not a class or if the class might not be dynamic.
bool mayBeNotDynamicClass() const;

// Don't promise in the API that anything besides 'const' can be
// easily added.

/// Add the `const` type qualifier to this QualType.
void addConst() {
  addFastQualifiers(Qualifiers::Const);
}
QualType withConst() const {
  return withFastQualifiers(Qualifiers::Const);
}

/// Add the `volatile` type qualifier to this QualType.
void addVolatile() {
  addFastQualifiers(Qualifiers::Volatile);
}
QualType withVolatile() const {
  return withFastQualifiers(Qualifiers::Volatile);
}

/// Add the `restrict` qualifier to this QualType.
void addRestrict() {
  addFastQualifiers(Qualifiers::Restrict);
}
QualType withRestrict() const {
  return withFastQualifiers(Qualifiers::Restrict);
}

QualType withCVRQualifiers(unsigned CVR) const {
  return withFastQualifiers(CVR);
}

void addFastQualifiers(unsigned TQs) {
  assert(!(TQs & ~Qualifiers::FastMask)((void)0)
         && "non-fast qualifier bits set in mask!")((void)0);
  Value.setInt(Value.getInt() | TQs);
}

void removeLocalConst();
void removeLocalVolatile();
void removeLocalRestrict();
void removeLocalCVRQualifiers(unsigned Mask);

void removeLocalFastQualifiers() { Value.setInt(0); }
void removeLocalFastQualifiers(unsigned Mask) {
  assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((void)0);
  Value.setInt(Value.getInt() & ~Mask);
}

// Creates a type with the given qualifiers in addition to any
// qualifiers already on this type.
QualType withFastQualifiers(unsigned TQs) const {
  QualType T = *this;
  T.addFastQualifiers(TQs);
  return T;
}

// Creates a type with exactly the given fast qualifiers, removing
// any existing fast qualifiers.
QualType withExactLocalFastQualifiers(unsigned TQs) const {
  return withoutLocalFastQualifiers().withFastQualifiers(TQs);
}

// Removes fast qualifiers, but leaves any extended qualifiers in place.
QualType withoutLocalFastQualifiers() const {
  QualType T = *this;
  T.removeLocalFastQualifiers();
  return T;
}

QualType getCanonicalType() const;

/// Return this type with all of the instance-specific qualifiers
/// removed, but without removing any qualifiers that may have been applied
/// through typedefs.
QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }

/// Retrieve the unqualified variant of the given type,
/// removing as little sugar as possible.
///
/// This routine looks through various kinds of sugar to find the
/// least-desugared type that is unqualified. For example, given:
///
/// \code
/// typedef int Integer;
/// typedef const Integer CInteger;
/// typedef CInteger DifferenceType;
/// \endcode
///
/// Executing \c getUnqualifiedType() on the type \c DifferenceType will
/// desugar until we hit the type \c Integer, which has no qualifiers on it.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline QualType getUnqualifiedType() const;

/// Retrieve the unqualified variant of the given type, removing as little
/// sugar as possible.
///
/// Like getUnqualifiedType(), but also returns the set of
/// qualifiers that were built up.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline SplitQualType getSplitUnqualifiedType() const;

/// Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// Determine whether this type is at least as qualified as the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isAtLeastAsQualifiedAs(QualType Other) const;

QualType getNonReferenceType() const;

/// Determine the type of a (typically non-lvalue) expression with the
/// specified result type.
///
/// This routine should be used for expressions for which the return type is
/// explicitly specified (e.g., in a cast or call) and isn't necessarily
/// an lvalue. It removes a top-level reference (since there are no
/// expressions of reference type) and deletes top-level cvr-qualifiers
/// from non-class types (in C++) or all types (in C).
QualType getNonLValueExprType(const ASTContext &Context) const;

/// Remove an outer pack expansion type (if any) from this type. Used as part
/// of converting the type of a declaration to the type of an expression that
/// references that expression. It's meaningless for an expression to have a
/// pack expansion type.
QualType getNonPackExpansionType() const;

/// Return the specified type with any "sugar" removed from
/// the type.  This takes off typedefs, typeof's etc.  If the outer level of
/// the type is already concrete, it returns it unmodified.  This is similar
/// to getting the canonical type, but it doesn't remove *all* typedefs.  For
/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
/// concrete.
///
/// Qualifiers are left in place.
QualType getDesugaredType(const ASTContext &Context) const {
  return getDesugaredType(*this, Context);
}

SplitQualType getSplitDesugaredType() const {
  return getSplitDesugaredType(*this);
}

/// Return the specified type with one level of "sugar" removed from
/// the type.
///
/// This routine takes off the first typedef, typeof, etc. If the outer level
/// of the type is already concrete, it returns it unmodified.
QualType getSingleStepDesugaredType(const ASTContext &Context) const {
  return getSingleStepDesugaredTypeImpl(*this, Context);
}

/// Returns the specified type after dropping any
/// outer-level parentheses.
QualType IgnoreParens() const {
  if (isa<ParenType>(*this))
    return QualType::IgnoreParens(*this);
  return *this;
}

/// Indicate whether the specified types and qualifiers are identical.
friend bool operator==(const QualType &LHS, const QualType &RHS) {
  return LHS.Value == RHS.Value;
}
friend bool operator!=(const QualType &LHS, const QualType &RHS) {
  return LHS.Value != RHS.Value;
}
friend bool operator<(const QualType &LHS, const QualType &RHS) {
  return LHS.Value < RHS.Value;
}

static std::string getAsString(SplitQualType split,
                               const PrintingPolicy &Policy) {
  return getAsString(split.Ty, split.Quals, Policy);
}
static std::string getAsString(const Type *ty, Qualifiers qs,
                               const PrintingPolicy &Policy);

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

void print(raw_ostream &OS, const PrintingPolicy &Policy,
           const Twine &PlaceHolder = Twine(),
           unsigned Indentation = 0) const;

static void print(SplitQualType split, raw_ostream &OS,
                  const PrintingPolicy &policy, const Twine &PlaceHolder,
                  unsigned Indentation = 0) {
  return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
}

static void print(const Type *ty, Qualifiers qs,
                  raw_ostream &OS, const PrintingPolicy &policy,
                  const Twine &PlaceHolder,
                  unsigned Indentation = 0);

void getAsStringInternal(std::string &Str,
                         const PrintingPolicy &Policy) const;

static void getAsStringInternal(SplitQualType split, std::string &out,
                                const PrintingPolicy &policy) {
  return getAsStringInternal(split.Ty, split.Quals, out, policy);
}

static void getAsStringInternal(const Type *ty, Qualifiers qs,
                                std::string &out,
                                const PrintingPolicy &policy);

class StreamedQualTypeHelper {
  const QualType &T;
  const PrintingPolicy &Policy;
  const Twine &PlaceHolder;
  unsigned Indentation;

public:
  StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
                         const Twine &PlaceHolder, unsigned Indentation)
      : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
        Indentation(Indentation) {}

  friend raw_ostream &operator<<(raw_ostream &OS,
                                 const StreamedQualTypeHelper &SQT) {
    SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
    return OS;
  }
};

StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
                              const Twine &PlaceHolder = Twine(),
                              unsigned Indentation = 0) const {
  return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
}

void dump(const char *s) const;
void dump() const;
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddPointer(getAsOpaquePtr());
}

/// Check if this type has any address space qualifier.
inline bool hasAddressSpace() const;

/// Return the address space of this type.
inline LangAS getAddressSpace() const;

/// Returns true if address space qualifiers overlap with T address space
/// qualifiers.
/// OpenCL C defines conversion rules for pointers to different address spaces
/// and notion of overlapping address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// OpenCL C v2.0 s6.5.5 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(QualType T) const {
  Qualifiers Q = getQualifiers();
  Qualifiers TQ = T.getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
}

/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;

/// true when Type is objc's weak.
bool isObjCGCWeak() const {
  return getObjCGCAttr() == Qualifiers::Weak;
}

/// true when Type is objc's strong.
bool isObjCGCStrong() const {
  return getObjCGCAttr() == Qualifiers::Strong;
}

/// Returns lifetime attribute of this type.
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return getQualifiers().getObjCLifetime();
}

bool hasNonTrivialObjCLifetime() const {
  return getQualifiers().hasNonTrivialObjCLifetime();
}

bool hasStrongOrWeakObjCLifetime() const {
  return getQualifiers().hasStrongOrWeakObjCLifetime();
}

// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;

enum PrimitiveDefaultInitializeKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,

  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct
};

/// Functions to query basic properties of non-trivial C struct types.

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to default initialize
/// and return the kind.
PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const;

enum PrimitiveCopyKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,

  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,

  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct
};

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to copy and return the
/// kind.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to destructively
/// move and return the kind. Destructive move in this context is a C++-style
/// move in which the source object is placed in a valid but unspecified state
/// after it is moved, as opposed to a truly destructive move in which the
/// source object is placed in an uninitialized state.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;

enum DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct
};

/// Returns a nonzero value if objects of this type require
/// non-trivial work to clean up after.  Non-zero because it's
/// conceivable that qualifiers (objc_gc(weak)?) could make
/// something require destruction.
DestructionKind isDestructedType() const {
  return isDestructedTypeImpl(*this);
}

/// Check if this is or contains a C union that is non-trivial to
/// default-initialize, which is a union that has a member that is non-trivial
/// to default-initialize. If this returns true,
/// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;

/// Check if this is or contains a C union that is non-trivial to destruct,
/// which is a union that has a member that is non-trivial to destruct. If
/// this returns true, isDestructedType returns DK_nontrivial_c_struct.
bool hasNonTrivialToPrimitiveDestructCUnion() const;

/// Check if this is or contains a C union that is non-trivial to copy, which
/// is a union that has a member that is non-trivial to copy. If this returns
/// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
bool hasNonTrivialToPrimitiveCopyCUnion() const;

/// Determine whether expressions of the given type are forbidden
/// from being lvalues in C.
///
/// The expression types that are forbidden to be lvalues are:
///   - 'void', but not qualified void
///   - function types
///
/// The exact rule here is C99 6.3.2.1:
///   An lvalue is an expression with an object type or an incomplete
///   type other than void.
bool isCForbiddenLValueType() const;

/// Substitute type arguments for the Objective-C type parameters used in the
/// subject type.
///
/// \param ctx ASTContext in which the type exists.
///
/// \param typeArgs The type arguments that will be substituted for the
/// Objective-C type parameters in the subject type, which are generally
/// computed via \c Type::getObjCSubstitutions. If empty, the type
/// parameters will be replaced with their bounds or id/Class, as appropriate
/// for the context.
///
/// \param context The context in which the subject type was written.
///
/// \returns the resulting type.
QualType substObjCTypeArgs(ASTContext &ctx,
                           ArrayRef<QualType> typeArgs,
                           ObjCSubstitutionContext context) const;

/// Substitute type arguments from an object type for the Objective-C type
/// parameters used in the subject type.
///
/// This operation combines the computation of type arguments for
/// substitution (\c Type::getObjCSubstitutions) with the actual process of
/// substitution (\c QualType::substObjCTypeArgs) for the convenience of
/// callers that need to perform a single substitution in isolation.
///
/// \param objectType The type of the object whose member type we're
/// substituting into. For example, this might be the receiver of a message
/// or the base of a property access.
///
/// \param dc The declaration context from which the subject type was
/// retrieved, which indicates (for example) which type parameters should
/// be substituted.
///
/// \param context The context in which the subject type was written.
///
/// \returns the subject type after replacing all of the Objective-C type
/// parameters with their corresponding arguments.
QualType substObjCMemberType(QualType objectType,
                             const DeclContext *dc,
                             ObjCSubstitutionContext context) const;

/// Strip Objective-C "__kindof" types from the given type.
QualType stripObjCKindOfType(const ASTContext &ctx) const;

/// Remove all qualifiers including _Atomic.
QualType getAtomicUnqualifiedType() const;

1289private:
// These methods are implemented in a separate translation unit;
// "static"-ize them to avoid creating temporary QualTypes in the
// caller.
static bool isConstant(QualType T, const ASTContext& Ctx);
static QualType getDesugaredType(QualType T, const ASTContext &Context);
static SplitQualType getSplitDesugaredType(QualType T);
static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
static QualType getSingleStepDesugaredTypeImpl(QualType type,
                                               const ASTContext &C);
static QualType IgnoreParens(QualType T);
static DestructionKind isDestructedTypeImpl(QualType type);

/// Check if \param RD is or contains a non-trivial C union.
static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1306};

1308} // namespace clang

1310namespace llvm {

1312/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1313/// to a specific Type class.
1314template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1320};

1322// Teach SmallPtrSet that QualType is "basically a pointer".
1323template<>
1324struct PointerLikeTypeTraits<clang::QualType> {
static inline void *getAsVoidPointer(clang::QualType P) {
  return P.getAsOpaquePtr();
}

static inline clang::QualType getFromVoidPointer(void *P) {
  return clang::QualType::getFromOpaquePtr(P);
}

// Various qualifiers go in low bits.
static constexpr int NumLowBitsAvailable = 0;
1335};

1337} // namespace llvm

1339namespace clang {

1341/// Base class that is common to both the \c ExtQuals and \c Type
1342/// classes, which allows \c QualType to access the common fields between the
1343/// two.
1344class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// The "base" type of an extended qualifiers type (\c ExtQuals) or
/// a self-referential pointer (for \c Type).
///
/// This pointer allows an efficient mapping from a QualType to its
/// underlying type pointer.
const Type *const BaseType;

/// The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1361};

1363/// We can encode up to four bits in the low bits of a
1364/// type pointer, but there are many more type qualifiers that we want
1365/// to be able to apply to an arbitrary type.  Therefore we have this
1366/// struct, intended to be heap-allocated and used by QualType to
1367/// store qualifiers.
1368///
1369/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1370/// in three low bits on the QualType pointer; a fourth bit records whether
1371/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1372/// Objective-C GC attributes) are much more rare.
1373class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
// NOTE: changing the fast qualifiers should be straightforward as
// long as you don't make 'const' non-fast.
// 1. Qualifiers:
//    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
//       Fast qualifiers must occupy the low-order bits.
//    b) Update Qualifiers::FastWidth and FastMask.
// 2. QualType:
//    a) Update is{Volatile,Restrict}Qualified(), defined inline.
//    b) Update remove{Volatile,Restrict}, defined near the end of
//       this header.
// 3. ASTContext:
//    a) Update get{Volatile,Restrict}Type.

/// The immutable set of qualifiers applied by this node. Always contains
/// extended qualifiers.
Qualifiers Quals;

ExtQuals *this_() { return this; }

1393public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((void)0)
         && "ExtQuals created with no fast qualifiers")((void)0);
  assert(!Quals.hasFastQualifiers()((void)0)
         && "ExtQuals created with fast qualifiers")((void)0);
}

Qualifiers getQualifiers() const { return Quals; }

bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }

bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return Quals.getObjCLifetime();
}

bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
LangAS getAddressSpace() const { return Quals.getAddressSpace(); }

const Type *getBaseType() const { return BaseType; }

1419public:
void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, getBaseType(), Quals);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const Type *BaseType,
                    Qualifiers Quals) {
  assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((void)0);
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1431};

1433/// The kind of C++11 ref-qualifier associated with a function type.
1434/// This determines whether a member function's "this" object can be an
1435/// lvalue, rvalue, or neither.
1436enum RefQualifierKind {
/// No ref-qualifier was provided.
RQ_None = 0,

/// An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1445};

1447/// Which keyword(s) were used to create an AutoType.
1448enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1457};

1459/// The base class of the type hierarchy.
1460///
1461/// A central concept with types is that each type always has a canonical
1462/// type.  A canonical type is the type with any typedef names stripped out
1463/// of it or the types it references.  For example, consider:
1464///
1465///  typedef int  foo;
1466///  typedef foo* bar;
1467///    'int *'    'foo *'    'bar'
1468///
1469/// There will be a Type object created for 'int'.  Since int is canonical, its
1470/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1471/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1472/// there is a PointerType that represents 'int*', which, like 'int', is
1473/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1474/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1475/// is also 'int*'.
1476///
1477/// Non-canonical types are useful for emitting diagnostics, without losing
1478/// information about typedefs being used.  Canonical types are useful for type
1479/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1480/// about whether something has a particular form (e.g. is a function type),
1481/// because they implicitly, recursively, strip all typedefs out of a type.
1482///
1483/// Types, once created, are immutable.
1484///
1485class alignas(8) Type : public ExtQualsTypeCommonBase {
1486public:
enum TypeClass {
1488#define TYPE(Class, Base) Class,
1489#define LAST_TYPE(Class) TypeLast = Class
1490#define ABSTRACT_TYPE(Class, Base)
1491#include "clang/AST/TypeNodes.inc"
};

1494private:
/// Bitfields required by the Type class.
class TypeBitfields {
  friend class Type;
  template <class T> friend class TypePropertyCache;

  /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
  unsigned TC : 8;

  /// Store information on the type dependency.
  unsigned Dependence : llvm::BitWidth<TypeDependence>;

  /// True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// Whether this type comes from an AST file.
  mutable unsigned FromAST : 1;

  bool isCacheValid() const {
    return CacheValid;
  }

  Linkage getLinkage() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };

1535protected:
// These classes allow subclasses to somewhat cleanly pack bitfields
// into Type.

class ArrayTypeBitfields {
  friend class ArrayType;

  unsigned : NumTypeBits;

  /// CVR qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  unsigned IndexTypeQuals : 3;

  /// Storage class qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  /// Actually an ArrayType::ArraySizeModifier.
  unsigned SizeModifier : 3;
};

class ConstantArrayTypeBitfields {
  friend class ConstantArrayType;

  unsigned : NumTypeBits + 3 + 3;

  /// Whether we have a stored size expression.
  unsigned HasStoredSizeExpr : 1;
};

class BuiltinTypeBitfields {
  friend class BuiltinType;

  unsigned : NumTypeBits;

  /// The kind (BuiltinType::Kind) of builtin type this is.
  unsigned Kind : 8;
};

/// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
/// Only common bits are stored here. Additional uncommon bits are stored
/// in a trailing object after FunctionProtoType.
class FunctionTypeBitfields {
  friend class FunctionProtoType;
  friend class FunctionType;

  unsigned : NumTypeBits;

  /// Extra information which affects how the function is called, like
  /// regparm and the calling convention.
  unsigned ExtInfo : 13;

  /// The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;

  /// Used only by FunctionProtoType, put here to pack with the
  /// other bitfields.
  /// The qualifiers are part of FunctionProtoType because...
  ///
  /// C++ 8.3.5p4: The return type, the parameter type list and the
  /// cv-qualifier-seq, [...], are part of the function type.
  unsigned FastTypeQuals : Qualifiers::FastWidth;
  /// Whether this function has extended Qualifiers.
  unsigned HasExtQuals : 1;

  /// The number of parameters this function has, not counting '...'.
  /// According to [implimits] 8 bits should be enough here but this is
  /// somewhat easy to exceed with metaprogramming and so we would like to
  /// keep NumParams as wide as reasonably possible.
  unsigned NumParams : 16;

  /// The type of exception specification this function has.
  unsigned ExceptionSpecType : 4;

  /// Whether this function has extended parameter information.
  unsigned HasExtParameterInfos : 1;

  /// Whether the function is variadic.
  unsigned Variadic : 1;

  /// Whether this function has a trailing return type.
  unsigned HasTrailingReturn : 1;
};

class ObjCObjectTypeBitfields {
  friend class ObjCObjectType;

  unsigned : NumTypeBits;

  /// The number of type arguments stored directly on this object type.
  unsigned NumTypeArgs : 7;

  /// The number of protocols stored directly on this object type.
  unsigned NumProtocols : 6;

  /// Whether this is a "kindof" type.
  unsigned IsKindOf : 1;
};

class ReferenceTypeBitfields {
  friend class ReferenceType;

  unsigned : NumTypeBits;

  /// True if the type was originally spelled with an lvalue sigil.
  /// This is never true of rvalue references but can also be false
  /// on lvalue references because of C++0x [dcl.typedef]p9,
  /// as follows:
  ///
  ///   typedef int &ref;    // lvalue, spelled lvalue
  ///   typedef int &&rvref; // rvalue
  ///   ref &a;              // lvalue, inner ref, spelled lvalue
  ///   ref &&a;             // lvalue, inner ref
  ///   rvref &a;            // lvalue, inner ref, spelled lvalue
  ///   rvref &&a;           // rvalue, inner ref
  unsigned SpelledAsLValue : 1;

  /// True if the inner type is a reference type.  This only happens
  /// in non-canonical forms.
  unsigned InnerRef : 1;
};

class TypeWithKeywordBitfields {
  friend class TypeWithKeyword;

  unsigned : NumTypeBits;

  /// An ElaboratedTypeKeyword.  8 bits for efficient access.
  unsigned Keyword : 8;
};

enum { NumTypeWithKeywordBits = 8 };

class ElaboratedTypeBitfields {
  friend class ElaboratedType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// Whether the ElaboratedType has a trailing OwnedTagDecl.
  unsigned HasOwnedTagDecl : 1;
};

class VectorTypeBitfields {
  friend class VectorType;
  friend class DependentVectorType;

  unsigned : NumTypeBits;

  /// The kind of vector, either a generic vector type or some
  /// target-specific vector type such as for AltiVec or Neon.
  unsigned VecKind : 3;
  /// The number of elements in the vector.
  uint32_t NumElements;
};

class AttributedTypeBitfields {
  friend class AttributedType;

  unsigned : NumTypeBits;

  /// An AttributedType::Kind
  unsigned AttrKind : 32 - NumTypeBits;
};

class AutoTypeBitfields {
  friend class AutoType;

  unsigned : NumTypeBits;

  /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
  /// or '__auto_type'?  AutoTypeKeyword value.
  unsigned Keyword : 2;

  /// The number of template arguments in the type-constraints, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class SubstTemplateTypeParmPackTypeBitfields {
  friend class SubstTemplateTypeParmPackType;

  unsigned : NumTypeBits;

  /// The number of template arguments in \c Arguments, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class TemplateSpecializationTypeBitfields {
  friend class TemplateSpecializationType;

  unsigned : NumTypeBits;

  /// Whether this template specialization type is a substituted type alias.
  unsigned TypeAlias : 1;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class DependentTemplateSpecializationTypeBitfields {
  friend class DependentTemplateSpecializationType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class PackExpansionTypeBitfields {
  friend class PackExpansionType;

  unsigned : NumTypeBits;

  /// The number of expansions that this pack expansion will
  /// generate when substituted (+1), which is expected to be able to
  /// hold at least 1024 according to [implimits]. However, as this limit
  /// is somewhat easy to hit with template metaprogramming we'd prefer to
  /// keep it as large as possible. At the moment it has been left as a
  /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
  /// there is no reason to introduce the performance impact of a bitfield.
  ///
  /// This field will only have a non-zero value when some of the parameter
  /// packs that occur within the pattern have been substituted but others
  /// have not.
  unsigned NumExpansions;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  ConstantArrayTypeBitfields ConstantArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  ElaboratedTypeBitfields ElaboratedTypeBits;
  VectorTypeBitfields VectorTypeBits;
  SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
  TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
  DependentTemplateSpecializationTypeBitfields
    DependentTemplateSpecializationTypeBits;
  PackExpansionTypeBitfields PackExpansionTypeBits;
};

1807private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1815protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, TypeDependence Dependence)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
                "changing bitfields changed sizeof(Type)!");
  static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
                "Insufficient alignment!");
  TypeBits.TC = tc;
  TypeBits.Dependence = static_cast<unsigned>(Dependence);
  TypeBits.CacheValid = false;
  TypeBits.CachedLocalOrUnnamed = false;
  TypeBits.CachedLinkage = NoLinkage;
  TypeBits.FromAST = false;
}

// silence VC++ warning C4355: 'this' : used in base member initializer list
Type *this_() { return this; }

void setDependence(TypeDependence D) {
  TypeBits.Dependence = static_cast<unsigned>(D);
}

void addDependence(TypeDependence D) { setDependence(getDependence() | D); }

1842public:
friend class ASTReader;
friend class ASTWriter;
template <class T> friend class serialization::AbstractTypeReader;
template <class T> friend class serialization::AbstractTypeWriter;

Type(const Type &) = delete;
Type(Type &&) = delete;
Type &operator=(const Type &) = delete;
Type &operator=(Type &&) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// Whether this type is or contains an unexpanded parameter
/// pack, used to support C++0x variadic templates.
///
/// A type that contains a parameter pack shall be expanded by the
/// ellipsis operator at some point. For example, the typedef in the
/// following example contains an unexpanded parameter pack 'T':
///
/// \code
/// template<typename ...T>
/// struct X {
///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
/// };
/// \endcode
///
/// Note that this routine does not specify which
bool containsUnexpandedParameterPack() const {
  return getDependence() & TypeDependence::UnexpandedPack;
}

/// Determines if this type would be canonical if it had no further
/// qualification.
bool isCanonicalUnqualified() const {
  return CanonicalType == QualType(this, 0);
}

/// Pull a single level of sugar off of this locally-unqualified type.
/// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
/// or QualType::getSingleStepDesugaredType(const ASTContext&).
QualType getLocallyUnqualifiedSingleStepDesugaredType() const;

/// As an extension, we classify types as one of "sized" or "sizeless";
/// every type is one or the other.  Standard types are all sized;
/// sizeless types are purely an extension.
///
/// Sizeless types contain data with no specified size, alignment,
/// or layout.
bool isSizelessType() const;
bool isSizelessBuiltinType() const;

/// Determines if this is a sizeless type supported by the
/// 'arm_sve_vector_bits' type attribute, which can be applied to a single
/// SVE vector or predicate, excluding tuple types such as svint32x4_t.
bool isVLSTBuiltinType() const;

/// Returns the representative type for the element of an SVE builtin type.
/// This is used to represent fixed-length SVE vectors created with the
/// 'arm_sve_vector_bits' type attribute as VectorType.
QualType getSveEltType(const ASTContext &Ctx) const;

/// Types are partitioned into 3 broad categories (C99 6.2.5p1):
/// object types, function types, and incomplete types.

/// Return true if this is an incomplete type.
/// A type that can describe objects, but which lacks information needed to
/// determine its size (e.g. void, or a fwd declared struct). Clients of this
/// routine will need to determine if the size is actually required.
///
/// Def If non-null, and the type refers to some kind of declaration
/// that can be completed (such as a C struct, C++ class, or Objective-C
/// class), will be set to the declaration.
bool isIncompleteType(NamedDecl **Def = nullptr) const;

/// Return true if this is an incomplete or object
/// type, in other words, not a function type.
bool isIncompleteOrObjectType() const {
  return !isFunctionType();
}

/// Determine whether this type is an object type.
bool isObjectType() const {
  // C++ [basic.types]p8:
  //   An object type is a (possibly cv-qualified) type that is not a
  //   function type, not a reference type, and not a void type.
  return !isReferenceType() && !isFunctionType() && !isVoidType();
}

/// Return true if this is a literal type
/// (C++11 [basic.types]p10)
bool isLiteralType(const ASTContext &Ctx) const;

/// Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isStructuralType() const;

/// Test if this type is a standard-layout type.
/// (C++0x [basic.type]p9)
bool isStandardLayoutType() const;

/// Helper methods to distinguish type categories. All type predicates
/// operate on the canonical type, ignoring typedefs and qualifiers.

/// Returns true if the type is a builtin type.
bool isBuiltinType() const;

/// Test for a particular builtin type.
bool isSpecificBuiltinType(unsigned K) const;

/// Test for a type which does not represent an actual type-system type but
/// is instead used as a placeholder for various convenient purposes within
/// Clang.  All such types are BuiltinTypes.
bool isPlaceholderType() const;
const BuiltinType *getAsPlaceholderType() const;

/// Test for a specific placeholder type.
bool isSpecificPlaceholderType(unsigned K) const;

/// Test for a placeholder type other than Overload; see
/// BuiltinType::isNonOverloadPlaceholderType.
bool isNonOverloadPlaceholderType() const;

/// isIntegerType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
bool isEnumeralType() const;

/// Determine whether this type is a scoped enumeration type.
bool isScopedEnumeralType() const;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() const;
bool isChar8Type() const;
bool isChar16Type() const;
bool isChar32Type() const;
bool isAnyCharacterType() const;
bool isIntegralType(const ASTContext &Ctx) const;

/// Determine whether this type is an integral or enumeration type.
bool isIntegralOrEnumerationType() const;

/// Determine whether this type is an integral or unscoped enumeration type.
bool isIntegralOrUnscopedEnumerationType() const;
bool isUnscopedEnumerationType() const;

/// Floating point categories.
bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
/// isComplexType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isComplexType() const;      // C99 6.2.5p11 (complex)
bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
bool isBFloat16Type() const;
bool isFloat128Type() const;
bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
bool isVoidType() const;         // C99 6.2.5p19
bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
bool isAggregateType() const;
bool isFundamentalType() const;
bool isCompoundType() const;

// Type Predicates: Check to see if this type is structurally the specified
// type, ignoring typedefs and qualifiers.
bool isFunctionType() const;
bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
bool isPointerType() const;
bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
bool isBlockPointerType() const;
bool isVoidPointerType() const;
bool isReferenceType() const;
bool isLValueReferenceType() const;
bool isRValueReferenceType() const;
bool isObjectPointerType() const;
bool isFunctionPointerType() const;
bool isFunctionReferenceType() const;
bool isMemberPointerType() const;
bool isMemberFunctionPointerType() const;
bool isMemberDataPointerType() const;
bool isArrayType() const;
bool isConstantArrayType() const;
bool isIncompleteArrayType() const;
bool isVariableArrayType() const;
bool isDependentSizedArrayType() const;
bool isRecordType() const;
bool isClassType() const;
bool isStructureType() const;
bool isObjCBoxableRecordType() const;
bool isInterfaceType() const;
bool isStructureOrClassType() const;
bool isUnionType() const;
bool isComplexIntegerType() const;            // GCC _Complex integer type.
bool isVectorType() const;                    // GCC vector type.
bool isExtVectorType() const;                 // Extended vector type.
bool isMatrixType() const;                    // Matrix type.
bool isConstantMatrixType() const;            // Constant matrix type.
bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
bool isObjCObjectPointerType() const;         // pointer to ObjC object
bool isObjCRetainableType() const;            // ObjC object or block pointer
bool isObjCLifetimeType() const;              // (array of)* retainable type
bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
bool isObjCNSObjectType() const;              // __attribute__((NSObject))
bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
// FIXME: change this to 'raw' interface type, so we can used 'interface' type
// for the common case.
bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
bool isObjCQualifiedIdType() const;           // id<foo>
bool isObjCQualifiedClassType() const;        // Class<foo>
bool isObjCObjectOrInterfaceType() const;
bool isObjCIdType() const;                    // id
bool isDecltypeType() const;
/// Was this type written with the special inert-in-ARC __unsafe_unretained
/// qualifier?
///
/// This approximates the answer to the following question: if this
/// translation unit were compiled in ARC, would this type be qualified
/// with __unsafe_unretained?
bool isObjCInertUnsafeUnretainedType() const {
  return hasAttr(attr::ObjCInertUnsafeUnretained);
}

/// Whether the type is Objective-C 'id' or a __kindof type of an
/// object type, e.g., __kindof NSView * or __kindof id
/// <NSCopying>.
///
/// \param bound Will be set to the bound on non-id subtype types,
/// which will be (possibly specialized) Objective-C class type, or
/// null for 'id.
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
                                const ObjCObjectType *&bound) const;

bool isObjCClassType() const;                 // Class

/// Whether the type is Objective-C 'Class' or a __kindof type of an
/// Class type, e.g., __kindof Class <NSCopying>.
///
/// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
/// here because Objective-C's type system cannot express "a class
/// object for a subclass of NSFoo".
bool isObjCClassOrClassKindOfType() const;

bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
bool isObjCSelType() const;                 // Class
bool isObjCBuiltinType() const;               // 'id' or 'Class'
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const;          // C++ template type parameter
bool isNullPtrType() const;                   // C++11 std::nullptr_t
bool isNothrowT() const;                      // C++   std::nothrow_t
bool isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()
bool isUndeducedAutoType() const;             // C++11 auto or
                                              // C++14 decltype(auto)
bool isTypedefNameType() const;               // typedef or alias template

2105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2107#include "clang/Basic/OpenCLImageTypes.def"

bool isImageType() const;                     // Any OpenCL image type

bool isSamplerT() const;                      // OpenCL sampler_t
bool isEventT() const;                        // OpenCL event_t
bool isClkEventT() const;                     // OpenCL clk_event_t
bool isQueueT() const;                        // OpenCL queue_t
bool isReserveIDT() const;                    // OpenCL reserve_id_t

2117#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2119#include "clang/Basic/OpenCLExtensionTypes.def"
// Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
bool isOCLIntelSubgroupAVCType() const;
bool isOCLExtOpaqueType() const;              // Any OpenCL extension type

bool isPipeType() const;                      // OpenCL pipe type
bool isExtIntType() const;                    // Extended Int Type
bool isOpenCLSpecificType() const;            // Any OpenCL specific type

/// Determines if this type, which must satisfy
/// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
/// than implicitly __strong.
bool isObjCARCImplicitlyUnretainedType() const;

/// Check if the type is the CUDA device builtin surface type.
bool isCUDADeviceBuiltinSurfaceType() const;
/// Check if the type is the CUDA device builtin texture type.
bool isCUDADeviceBuiltinTextureType() const;

/// Return the implicit lifetime for this type, which must not be dependent.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;

enum ScalarTypeKind {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
  STK_FixedPoint
};

/// Given that this is a scalar type, classify it.
ScalarTypeKind getScalarTypeKind() const;

TypeDependence getDependence() const {
  return static_cast<TypeDependence>(TypeBits.Dependence);
}

/// Whether this type is an error type.
bool containsErrors() const {
  return getDependence() & TypeDependence::Error;
}

/// Whether this type is a dependent type, meaning that its definition
/// somehow depends on a template parameter (C++ [temp.dep.type]).
bool isDependentType() const {
  return getDependence() & TypeDependence::Dependent;
}

/// Determine whether this type is an instantiation-dependent type,
/// meaning that the type involves a template parameter (even if the
/// definition does not actually depend on the type substituted for that
/// template parameter).
bool isInstantiationDependentType() const {
  return getDependence() & TypeDependence::Instantiation;
}

/// Determine whether this type is an undeduced type, meaning that
/// it somehow involves a C++11 'auto' type or similar which has not yet been
/// deduced.
bool isUndeducedType() const;

/// Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const {
  return getDependence() & TypeDependence::VariablyModified;
}

/// Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// Determine wither this type is a C++ elaborated-type-specifier.
bool isElaboratedTypeSpecifier() const;

bool canDecayToPointerType() const;

/// Whether this type is represented natively as a pointer.  This includes
/// pointers, references, block pointers, and Objective-C interface,
/// qualified id, and qualified interface types, as well as nullptr_t.
bool hasPointerRepresentation() const;

/// Whether this type can represent an objective pointer type for the
/// purpose of GC'ability
bool hasObjCPointerRepresentation() const;

/// Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// Determine whether this type has an signed integer representation
/// of some sort, e.g., it is an signed integer type or a vector.
bool hasSignedIntegerRepresentation() const;

/// Determine whether this type has an unsigned integer representation
/// of some sort, e.g., it is an unsigned integer type or a vector.
bool hasUnsignedIntegerRepresentation() const;

/// Determine whether this type has a floating-point representation
/// of some sort, e.g., it is a floating-point type or a vector thereof.
bool hasFloatingRepresentation() const;

// Type Checking Functions: Check to see if this type is structurally the
// specified type, ignoring typedefs and qualifiers, and return a pointer to
// the best type we can.
const RecordType *getAsStructureType() const;
/// NOTE: getAs*ArrayType are methods on ASTContext.
const RecordType *getAsUnionType() const;
const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
const ObjCObjectType *getAsObjCInterfaceType() const;

// The following is a convenience method that returns an ObjCObjectPointerType
// for object declared using an interface.
const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;

/// Retrieves the CXXRecordDecl that this type refers to, either
/// because the type is a RecordType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
CXXRecordDecl *getAsCXXRecordDecl() const;

/// Retrieves the RecordDecl this type refers to.
RecordDecl *getAsRecordDecl() const;

/// Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const;

/// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that the type refers to.
///
/// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const;

/// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
DeducedType *getContainedDeducedType() const;

/// Get the AutoType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
AutoType *getContainedAutoType() const {
  return dyn_cast_or_null<AutoType>(getContainedDeducedType());
}

/// Determine whether this type was written with a leading 'auto'
/// corresponding to a trailing return type (possibly for a nested
/// function type within a pointer to function type or similar).
bool hasAutoForTrailingReturnType() const;

/// Member-template getAs<specific type>'.  Look through sugar for
/// an instance of \<specific type>.   This scheme will eventually
/// replace the specific getAsXXXX methods above.
///
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;

/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
/// This is used when you need to walk over sugar nodes that represent some
/// kind of type adjustment from a type that was written as a \<specific type>
/// to another type that is still canonically a \<specific type>.
template <typename T> const T *getAsAdjusted() const;

/// A variant of getAs<> for array types which silently discards
/// qualifiers from the outermost type.
const ArrayType *getAsArrayTypeUnsafe() const;

/// Member-template castAs<specific type>.  Look through sugar for
/// the underlying instance of \<specific type>.
///
/// This method has the same relationship to getAs<T> as cast<T> has
/// to dyn_cast<T>; which is to say, the underlying type *must*
/// have the intended type, and this method will never return null.
template <typename T> const T *castAs() const;

/// A variant of castAs<> for array type which silently discards
/// qualifiers from the outermost type.
const ArrayType *castAsArrayTypeUnsafe() const;

/// Determine whether this type had the specified attribute applied to it
/// (looking through top-level type sugar).
bool hasAttr(attr::Kind AK) const;

/// Get the base element type of this type, potentially discarding type
/// qualifiers.  This should never be used when type qualifiers
/// are meaningful.
const Type *getBaseElementTypeUnsafe() const;

/// If this is an array type, return the element type of the array,
/// potentially with type qualifiers missing.
/// This should never be used when type qualifiers are meaningful.
const Type *getArrayElementTypeNoTypeQual() const;

/// If this is a pointer type, return the pointee type.
/// If this is an array type, return the array element type.
/// This should never be used when type qualifiers are meaningful.
const Type *getPointeeOrArrayElementType() const;

/// If this is a pointer, ObjC object pointer, or block
/// pointer, this returns the respective pointee.
QualType getPointeeType() const;

/// Return the specified type with any "sugar" removed from the type,
/// removing any typedefs, typeofs, etc., as well as any qualifiers.
const Type *getUnqualifiedDesugaredType() const;

/// More type predicates useful for type checking/promotion
bool isPromotableIntegerType() const; // C99 6.3.1.1p2

/// Return true if this is an integer type that is
/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
/// or an enum decl which has a signed representation.
bool isSignedIntegerType() const;

/// Return true if this is an integer type that is
/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
/// or an enum decl which has an unsigned representation.
bool isUnsignedIntegerType() const;

/// Determines whether this is an integer type that is signed or an
/// enumeration types whose underlying type is a signed integer type.
bool isSignedIntegerOrEnumerationType() const;

/// Determines whether this is an integer type that is unsigned or an
/// enumeration types whose underlying type is a unsigned integer type.
bool isUnsignedIntegerOrEnumerationType() const;

/// Return true if this is a fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169.
bool isFixedPointType() const;

/// Return true if this is a fixed point or integer type.
bool isFixedPointOrIntegerType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isSaturatedFixedPointType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isUnsaturatedFixedPointType() const;

/// Return true if this is a fixed point type that is signed according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isSignedFixedPointType() const;

/// Return true if this is a fixed point type that is unsigned according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isUnsignedFixedPointType() const;

/// Return true if this is not a variable sized type,
/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
/// incomplete types.
bool isConstantSizeType() const;

/// Returns true if this type can be represented by some
/// set of type specifiers.
bool isSpecifierType() const;

/// Determine the linkage of this type.
Linkage getLinkage() const;

/// Determine the visibility of this type.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Return true if the visibility was explicitly set is the code.
bool isVisibilityExplicit() const {
  return getLinkageAndVisibility().isVisibilityExplicit();
}

/// Determine the linkage and visibility of this type.
LinkageInfo getLinkageAndVisibility() const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// Determine the nullability of the given type.
///
/// Note that nullability is only captured as sugar within the type
/// system, not as part of the canonical type, so nullability will
/// be lost by canonicalization and desugaring.
Optional<NullabilityKind> getNullability(const ASTContext &context) const;

/// Determine whether the given type can have a nullability
/// specifier applied to it, i.e., if it is any kind of pointer type.
///
/// \param ResultIfUnknown The value to return if we don't yet know whether
///        this type can have nullability because it is dependent.
bool canHaveNullability(bool ResultIfUnknown = true) const;

/// Retrieve the set of substitutions required when accessing a member
/// of the Objective-C receiver type that is declared in the given context.
///
/// \c *this is the type of the object we're operating on, e.g., the
/// receiver for a message send or the base of a property access, and is
/// expected to be of some object or object pointer type.
///
/// \param dc The declaration context for which we are building up a
/// substitution mapping, which should be an Objective-C class, extension,
/// category, or method within.
///
/// \returns an array of type arguments that can be substituted for
/// the type parameters of the given declaration context in any type described
/// within that context, or an empty optional to indicate that no
/// substitution is required.
Optional<ArrayRef<QualType>>
getObjCSubstitutions(const DeclContext *dc) const;

/// Determines if this is an ObjC interface type that may accept type
/// parameters.
bool acceptsObjCTypeParams() const;

const char *getTypeClassName() const;

QualType getCanonicalTypeInternal() const {
  return CanonicalType;
}

CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
void dump() const;
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2458};

2460/// This will check for a TypedefType by removing any existing sugar
2461/// until it reaches a TypedefType or a non-sugared type.
2462template <> const TypedefType *Type::getAs() const;

2464/// This will check for a TemplateSpecializationType by removing any
2465/// existing sugar until it reaches a TemplateSpecializationType or a
2466/// non-sugared type.
2467template <> const TemplateSpecializationType *Type::getAs() const;

2469/// This will check for an AttributedType by removing any existing sugar
2470/// until it reaches an AttributedType or a non-sugared type.
2471template <> const AttributedType *Type::getAs() const;

2473// We can do canonical leaf types faster, because we don't have to
2474// worry about preserving child type decoration.
2475#define TYPE(Class, Base)
2476#define LEAF_TYPE(Class) \
2477template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2479} \
2480template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2482}
2483#include "clang/AST/TypeNodes.inc"

2485/// This class is used for builtin types like 'int'.  Builtin
2486/// types are always canonical and have a literal name field.
2487class BuiltinType : public Type {
2488public:
enum Kind {
2490// OpenCL image types
2491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2492#include "clang/Basic/OpenCLImageTypes.def"
2493// OpenCL extension types
2494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2495#include "clang/Basic/OpenCLExtensionTypes.def"
2496// SVE Types
2497#define SVE_TYPE(Name, Id, SingletonId) Id,
2498#include "clang/Basic/AArch64SVEACLETypes.def"
2499// PPC MMA Types
2500#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2501#include "clang/Basic/PPCTypes.def"
2502// RVV Types
2503#define RVV_TYPE(Name, Id, SingletonId) Id,
2504#include "clang/Basic/RISCVVTypes.def"
2505// All other builtin types
2506#define BUILTIN_TYPE(Id, SingletonId) Id,
2507#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2508#include "clang/AST/BuiltinTypes.def"
};

2511private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(),
           K == Dependent ? TypeDependence::DependentInstantiation
                          : TypeDependence::None) {
  BuiltinTypeBits.Kind = K;
}

2521public:
Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
StringRef getName(const PrintingPolicy &Policy) const;

const char *getNameAsCString(const PrintingPolicy &Policy) const {
  // The StringRef is null-terminated.
  StringRef str = getName(Policy);
  assert(!str.empty() && str.data()[str.size()] == '\0')((void)0);
  return str.data();
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

bool isInteger() const {
  return getKind() >= Bool && getKind() <= Int128;
}

bool isSignedInteger() const {
  return getKind() >= Char_S && getKind() <= Int128;
}

bool isUnsignedInteger() const {
  return getKind() >= Bool && getKind() <= UInt128;
}

bool isFloatingPoint() const {
  return getKind() >= Half && getKind() <= Float128;
}

/// Determines whether the given kind corresponds to a placeholder type.
static bool isPlaceholderTypeKind(Kind K) {
  return K >= Overload;
}

/// Determines whether this type is a placeholder type, i.e. a type
/// which cannot appear in arbitrary positions in a fully-formed
/// expression.
bool isPlaceholderType() const {
  return isPlaceholderTypeKind(getKind());
}

/// Determines whether this type is a placeholder type other than
/// Overload.  Most placeholder types require only syntactic
/// information about their context in order to be resolved (e.g.
/// whether it is a call expression), which means they can (and
/// should) be resolved in an earlier "phase" of analysis.
/// Overload expressions sometimes pick up further information
/// from their context, like whether the context expects a
/// specific function-pointer type, and so frequently need
/// special treatment.
bool isNonOverloadPlaceholderType() const {
  return getKind() > Overload;
}

static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2577};

2579/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2580/// types (_Complex float etc) as well as the GCC integer complex extensions.
2581class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->getDependence()),
      ElementType(Element) {}

2590public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
  ID.AddPointer(Element.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2605};

2607/// Sugar for parentheses used when specifying types.
2608class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}

2616public:
QualType getInnerType() const { return Inner; }

bool isSugared() const { return true; }
QualType desugar() const { return getInnerType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getInnerType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
  Inner.Profile(ID);
}

static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2631};

2633/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2634class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
      PointeeType(Pointee) {}

2643public:
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2658};

2660/// Represents a type which was implicitly adjusted by the semantic
2661/// engine for arbitrary reasons.  For example, array and function types can
2662/// decay, and function types can have their calling conventions adjusted.
2663class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2667protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2675public:
QualType getOriginalType() const { return OriginalTy; }
QualType getAdjustedType() const { return AdjustedTy; }

bool isSugared() const { return true; }
QualType desugar() const { return AdjustedTy; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, OriginalTy, AdjustedTy);
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
  ID.AddPointer(Orig.getAsOpaquePtr());
  ID.AddPointer(New.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
}
2694};

2696/// Represents a pointer type decayed from an array or function type.
2697class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2703public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2709};

2711/// Pointer to a block type.
2712/// This type is to represent types syntactically represented as
2713/// "void (^)(int)", etc. Pointee is required to always be a function type.
2714class BlockPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

// Block is some kind of pointer type
QualType PointeeType;

BlockPointerType(QualType Pointee, QualType CanonicalCls)
    : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
      PointeeType(Pointee) {}

2724public:
// Get the pointee type. Pointee is required to always be a function type.
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
    Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
    ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == BlockPointer;
}
2742};

2744/// Base for LValueReferenceType and RValueReferenceType
2745class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2748protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->getDependence()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2757public:
bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }

QualType getPointeeTypeAsWritten() const { return PointeeType; }

QualType getPointeeType() const {
  // FIXME: this might strip inner qualifiers; okay?
  const ReferenceType *T = this;
  while (T->isInnerRef())
    T = T->PointeeType->castAs<ReferenceType>();
  return T->PointeeType;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, PointeeType, isSpelledAsLValue());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Referencee,
                    bool SpelledAsLValue) {
  ID.AddPointer(Referencee.getAsOpaquePtr());
  ID.AddBoolean(SpelledAsLValue);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference ||
         T->getTypeClass() == RValueReference;
}
2786};

2788/// An lvalue reference type, per C++11 [dcl.ref].
2789class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2797public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2804};

2806/// An rvalue reference type, per C++11 [dcl.ref].
2807class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2813public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2820};

2822/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2823///
2824/// This includes both pointers to data members and pointer to member functions.
2825class MemberPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

/// The class of which the pointee is a member. Must ultimately be a
/// RecordType, but could be a typedef or a template parameter too.
const Type *Class;

MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
    : Type(MemberPointer, CanonicalPtr,
           (Cls->getDependence() & ~TypeDependence::VariablyModified) |
               Pointee->getDependence()),
      PointeeType(Pointee), Class(Cls) {}

2840public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if the member type (i.e. the pointee type) is a
/// function type rather than a data-member type.
bool isMemberFunctionPointer() const {
  return PointeeType->isFunctionProtoType();
}

/// Returns true if the member type (i.e. the pointee type) is a
/// data type rather than a function type.
bool isMemberDataPointer() const {
  return !PointeeType->isFunctionProtoType();
}

const Type *getClass() const { return Class; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType(), getClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
                    const Type *Class) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
  ID.AddPointer(Class);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == MemberPointer;
}
2874};

2876/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2877class ArrayType : public Type, public llvm::FoldingSetNode {
2878public:
/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum ArraySizeModifier {
  Normal, Static, Star
};

2887private:
/// The element type of the array.
QualType ElementType;

2891protected:
friend class ASTContext; // ASTContext creates these.

ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
          unsigned tq, const Expr *sz = nullptr);

2897public:
QualType getElementType() const { return ElementType; }

ArraySizeModifier getSizeModifier() const {
  return ArraySizeModifier(ArrayTypeBits.SizeModifier);
}

Qualifiers getIndexTypeQualifiers() const {
  return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
}

unsigned getIndexTypeCVRQualifiers() const {
  return ArrayTypeBits.IndexTypeQuals;
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray ||
         T->getTypeClass() == VariableArray ||
         T->getTypeClass() == IncompleteArray ||
         T->getTypeClass() == DependentSizedArray;
}
2918};

2920/// Represents the canonical version of C arrays with a specified constant size.
2921/// For example, the canonical type for 'int A[4 + 4*100]' is a
2922/// ConstantArrayType where the element type is 'int' and the size is 404.
2923class ConstantArrayType final
  : public ArrayType,
    private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

llvm::APInt Size; // Allows us to unique the type.

ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
                  const Expr *sz, ArraySizeModifier sm, unsigned tq)
    : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
  ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
  if (ConstantArrayTypeBits.HasStoredSizeExpr) {
    assert(!can.isNull() && "canonical constant array should not have size")((void)0);
    *getTrailingObjects<const Expr*>() = sz;
  }
}

unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
  return ConstantArrayTypeBits.HasStoredSizeExpr;
}

2945public:
const llvm::APInt &getSize() const { return Size; }
const Expr *getSizeExpr() const {
  return ConstantArrayTypeBits.HasStoredSizeExpr
             ? *getTrailingObjects<const Expr *>()
             : nullptr;
}
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Determine the number of bits required to address a member of
// an array with the given element type and number of elements.
static unsigned getNumAddressingBits(const ASTContext &Context,
                                     QualType ElementType,
                                     const llvm::APInt &NumElements);

/// Determine the maximum number of active bits that an array's size
/// can require, which limits the maximum size of the array.
static unsigned getMaxSizeBits(const ASTContext &Context);

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
          getSizeModifier(), getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
                    QualType ET, const llvm::APInt &ArraySize,
                    const Expr *SizeExpr, ArraySizeModifier SizeMod,
                    unsigned TypeQuals);

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray;
}
2978};

2980/// Represents a C array with an unspecified size.  For example 'int A[]' has
2981/// an IncompleteArrayType where the element type is 'int' and the size is
2982/// unspecified.
2983class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq) {}

2990public:
friend class StmtIteratorBase;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == IncompleteArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSizeModifier(),
          getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    ArraySizeModifier SizeMod, unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}
3011};

3013/// Represents a C array with a specified size that is not an
3014/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3015/// Since the size expression is an arbitrary expression, we store it as such.
3016///
3017/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3018/// should not be: two lexically equivalent variable array types could mean
3019/// different things, for example, these variables do not have the same type
3020/// dynamically:
3021///
3022/// void foo(int x) {
3023///   int Y[x];
3024///   ++x;
3025///   int Z[x];
3026/// }
3027class VariableArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

/// An assignment-expression. VLA's are only permitted within
/// a function block.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

VariableArrayType(QualType et, QualType can, Expr *e,
                  ArraySizeModifier sm, unsigned tq,
                  SourceRange brackets)
    : ArrayType(VariableArray, et, can, sm, tq, e),
      SizeExpr((Stmt*) e), Brackets(brackets) {}

3043public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == VariableArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  llvm_unreachable("Cannot unique VariableArrayTypes.")__builtin_unreachable();
}
3066};

3068/// Represents an array type in C++ whose size is a value-dependent expression.
3069///
3070/// For example:
3071/// \code
3072/// template<typename T, int Size>
3073/// class array {
3074///   T data[Size];
3075/// };
3076/// \endcode
3077///
3078/// For these types, we won't actually know what the array bound is
3079/// until template instantiation occurs, at which point this will
3080/// become either a ConstantArrayType or a VariableArrayType.
3081class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// An assignment expression that will instantiate to the
/// size of the array.
///
/// The expression itself might be null, in which case the array
/// type will have its size deduced from an initializer.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
                        Expr *e, ArraySizeModifier sm, unsigned tq,
                        SourceRange brackets);

3100public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(),
          getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ET, ArraySizeModifier SizeMod,
                    unsigned TypeQuals, Expr *E);
3128};

3130/// Represents an extended address space qualifier where the input address space
3131/// value is dependent. Non-dependent address spaces are not represented with a
3132/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3133///
3134/// For example:
3135/// \code
3136/// template<typename T, int AddrSpace>
3137/// class AddressSpace {
3138///   typedef T __attribute__((address_space(AddrSpace))) type;
3139/// }
3140/// \endcode
3141class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *AddrSpaceExpr;
QualType PointeeType;
SourceLocation loc;

DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
                          QualType can, Expr *AddrSpaceExpr,
                          SourceLocation loc);

3153public:
Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
QualType getPointeeType() const { return PointeeType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentAddressSpace;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType PointeeType, Expr *AddrSpaceExpr);
3171};

3173/// Represents an extended vector type where either the type or size is
3174/// dependent.
3175///
3176/// For example:
3177/// \code
3178/// template<typename T, int Size>
3179/// class vector {
3180///   typedef T __attribute__((ext_vector_type(Size))) type;
3181/// }
3182/// \endcode
3183class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *SizeExpr;

/// The element type of the array.
QualType ElementType;

SourceLocation loc;

DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
                            QualType can, Expr *SizeExpr, SourceLocation loc);

3197public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedExtVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *SizeExpr);
3215};


3218/// Represents a GCC generic vector type. This type is created using
3219/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3220/// bytes; or from an Altivec __vector or vector declaration.
3221/// Since the constructor takes the number of vector elements, the
3222/// client is responsible for converting the size into the number of elements.
3223class VectorType : public Type, public llvm::FoldingSetNode {
3224public:
enum VectorKind {
  /// not a target-specific vector type
  GenericVector,

  /// is AltiVec vector
  AltiVecVector,

  /// is AltiVec 'vector Pixel'
  AltiVecPixel,

  /// is AltiVec 'vector bool ...'
  AltiVecBool,

  /// is ARM Neon vector
  NeonVector,

  /// is ARM Neon polynomial vector
  NeonPolyVector,

  /// is AArch64 SVE fixed-length data vector
  SveFixedLengthDataVector,

  /// is AArch64 SVE fixed-length predicate vector
  SveFixedLengthPredicateVector
};

3251protected:
friend class ASTContext; // ASTContext creates these.

/// The element type of the vector.
QualType ElementType;

VectorType(QualType vecType, unsigned nElements, QualType canonType,
           VectorKind vecKind);

VectorType(TypeClass tc, QualType vecType, unsigned nElements,
           QualType canonType, VectorKind vecKind);

3263public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

VectorKind getVectorKind() const {
  return VectorKind(VectorTypeBits.VecKind);
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumElements(),
          getTypeClass(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumElements, TypeClass TypeClass,
                    VectorKind VecKind) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumElements);
  ID.AddInteger(TypeClass);
  ID.AddInteger(VecKind);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
}
3291};

3293/// Represents a vector type where either the type or size is dependent.
3294////
3295/// For example:
3296/// \code
3297/// template<typename T, int Size>
3298/// class vector {
3299///   typedef T __attribute__((vector_size(Size))) type;
3300/// }
3301/// \endcode
3302class DependentVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
QualType ElementType;
Expr *SizeExpr;
SourceLocation Loc;

DependentVectorType(const ASTContext &Context, QualType ElementType,
                         QualType CanonType, Expr *SizeExpr,
                         SourceLocation Loc, VectorType::VectorKind vecKind);

3314public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return Loc; }
VectorType::VectorKind getVectorKind() const {
  return VectorType::VectorKind(VectorTypeBits.VecKind);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, const Expr *SizeExpr,
                    VectorType::VectorKind VecKind);
3336};

3338/// ExtVectorType - Extended vector type. This type is created using
3339/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341/// class enables syntactic extensions, like Vector Components for accessing
3342/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343/// Shading Language).
3344class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3350public:
static int getPointAccessorIdx(char c) {
  switch (c) {
  default: return -1;
  case 'x': case 'r': return 0;
  case 'y': case 'g': return 1;
  case 'z': case 'b': return 2;
  case 'w': case 'a': return 3;
  }
}

static int getNumericAccessorIdx(char c) {
  switch (c) {
    default: return -1;
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'A':
    case 'a': return 10;
    case 'B':
    case 'b': return 11;
    case 'C':
    case 'c': return 12;
    case 'D':
    case 'd': return 13;
    case 'E':
    case 'e': return 14;
    case 'F':
    case 'f': return 15;
  }
}

static int getAccessorIdx(char c, bool isNumericAccessor) {
  if (isNumericAccessor)
    return getNumericAccessorIdx(c);
  else
    return getPointAccessorIdx(c);
}

bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
  if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
    return unsigned(idx-1) < getNumElements();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ExtVector;
}
3408};

3410/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3411/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3412/// number of rows and "columns" specifies the number of columns.
3413class MatrixType : public Type, public llvm::FoldingSetNode {
3414protected:
friend class ASTContext;

/// The element type of the matrix.
QualType ElementType;

MatrixType(QualType ElementTy, QualType CanonElementTy);

MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
           const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);

3425public:
/// Returns type of the elements being stored in the matrix
QualType getElementType() const { return ElementType; }

/// Valid elements types are the following:
/// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
///   and _Bool
/// * the standard floating types float or double
/// * a half-precision floating point type, if one is supported on the target
static bool isValidElementType(QualType T) {
  return T->isDependentType() ||
         (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix ||
         T->getTypeClass() == DependentSizedMatrix;
}
3446};

3448/// Represents a concrete matrix type with constant number of rows and columns
3449class ConstantMatrixType final : public MatrixType {
3450protected:
friend class ASTContext;

/// The element type of the matrix.
// FIXME: Appears to be unused? There is also MatrixType::ElementType...
QualType ElementType;

/// Number of rows and columns.
unsigned NumRows;
unsigned NumColumns;

static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;

ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

3469public:
/// Returns the number of rows in the matrix.
unsigned getNumRows() const { return NumRows; }

/// Returns the number of columns in the matrix.
unsigned getNumColumns() const { return NumColumns; }

/// Returns the number of elements required to embed the matrix into a vector.
unsigned getNumElementsFlattened() const {
  return getNumRows() * getNumColumns();
}

/// Returns true if \p NumElements is a valid matrix dimension.
static constexpr bool isDimensionValid(size_t NumElements) {
  return NumElements > 0 && NumElements <= MaxElementsPerDimension;
}

/// Returns the maximum number of elements per dimension.
static constexpr unsigned getMaxElementsPerDimension() {
  return MaxElementsPerDimension;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumRows(), getNumColumns(),
          getTypeClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumRows, unsigned NumColumns,
                    TypeClass TypeClass) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumRows);
  ID.AddInteger(NumColumns);
  ID.AddInteger(TypeClass);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix;
}
3508};

3510/// Represents a matrix type where the type and the number of rows and columns
3511/// is dependent on a template.
3512class DependentSizedMatrixType final : public MatrixType {
friend class ASTContext;

const ASTContext &Context;
Expr *RowExpr;
Expr *ColumnExpr;

SourceLocation loc;

DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
                         QualType CanonicalType, Expr *RowExpr,
                         Expr *ColumnExpr, SourceLocation loc);

3525public:
QualType getElementType() const { return ElementType; }
Expr *getRowExpr() const { return RowExpr; }
Expr *getColumnExpr() const { return ColumnExpr; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedMatrix;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3544};

3546/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3547/// class of FunctionNoProtoType and FunctionProtoType.
3548class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3552public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type. This is only used by FunctionProtoType
/// but is in FunctionType to make this class available during the
/// specification of the bases of FunctionProtoType.
///
/// It makes sense to model language features this way when there's some
/// sort of parameter-specific override (such as an attribute) that
/// affects how the function is called.  For example, the ARC ns_consumed
/// attribute changes whether a parameter is passed at +0 (the default)
/// or +1 (ns_consumed).  This must be reflected in the function type,
/// but isn't really a change to the parameter type.
///
/// One serious disadvantage of modelling language features this way is
/// that they generally do not work with language features that attempt
/// to destructure types.  For example, template argument deduction will
/// not be able to match a parameter declared as
///   T (*)(U)
/// against an argument of type
///   void (*)(__attribute__((ns_consumed)) id)
/// because the substitution of T=void, U=id into the former will
/// not produce the latter.
class ExtParameterInfo {
  enum {
    ABIMask = 0x0F,
    IsConsumed = 0x10,
    HasPassObjSize = 0x20,
    IsNoEscape = 0x40,
  };
  unsigned char Data = 0;

public:
  ExtParameterInfo() = default;

  /// Return the ABI treatment of this parameter.
  ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
  ExtParameterInfo withABI(ParameterABI kind) const {
    ExtParameterInfo copy = *this;
    copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
    return copy;
  }

  /// Is this parameter considered "consumed" by Objective-C ARC?
  /// Consumed parameters must have retainable object type.
  bool isConsumed() const { return (Data & IsConsumed); }
  ExtParameterInfo withIsConsumed(bool consumed) const {
    ExtParameterInfo copy = *this;
    if (consumed)
      copy.Data |= IsConsumed;
    else
      copy.Data &= ~IsConsumed;
    return copy;
  }

  bool hasPassObjectSize() const { return Data & HasPassObjSize; }
  ExtParameterInfo withHasPassObjectSize() const {
    ExtParameterInfo Copy = *this;
    Copy.Data |= HasPassObjSize;
    return Copy;
  }

  bool isNoEscape() const { return Data & IsNoEscape; }
  ExtParameterInfo withIsNoEscape(bool NoEscape) const {
    ExtParameterInfo Copy = *this;
    if (NoEscape)
      Copy.Data |= IsNoEscape;
    else
      Copy.Data &= ~IsNoEscape;
    return Copy;
  }

  unsigned char getOpaqueValue() const { return Data; }
  static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
    ExtParameterInfo result;
    result.Data = data;
    return result;
  }

  friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data == rhs.Data;
  }

  friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data != rhs.Data;
  }
};

/// A class which abstracts out some details necessary for
/// making a call.
///
/// It is not actually used directly for storing this information in
/// a FunctionType, although FunctionType does currently use the
/// same bit-pattern.
///
// If you add a field (say Foo), other than the obvious places (both,
// constructors, compile failures), what you need to update is
// * Operator==
// * getFoo
// * withFoo
// * functionType. Add Foo, getFoo.
// * ASTContext::getFooType
// * ASTContext::mergeFunctionTypes
// * FunctionNoProtoType::Profile
// * FunctionProtoType::Profile
// * TypePrinter::PrintFunctionProto
// * AST read and write
// * Codegen
class ExtInfo {
  friend class FunctionType;

  // Feel free to rearrange or add bits, but if you go over 16, you'll need to
  // adjust the Bits field below, and if you add bits, you'll need to adjust
  // Type::FunctionTypeBitfields::ExtInfo as well.

  // |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
  // |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |    12    |
  //
  // regparm is either 0 (no regparm attribute) or the regparm value+1.
  enum { CallConvMask = 0x1F };
  enum { NoReturnMask = 0x20 };
  enum { ProducesResultMask = 0x40 };
  enum { NoCallerSavedRegsMask = 0x80 };
  enum {
    RegParmMask =  0x700,
    RegParmOffset = 8
  };
  enum { NoCfCheckMask = 0x800 };
  enum { CmseNSCallMask = 0x1000 };
  uint16_t Bits = CC_C;

  ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

public:
  // Constructor with no defaults. Use this when you know that you
  // have all the elements (when reading an AST file for example).
  ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
          bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
          bool cmseNSCall) {
    assert((!hasRegParm || regParm < 7) && "Invalid regparm value")((void)0);
    Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
           (producesResult ? ProducesResultMask : 0) |
           (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
           (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
           (NoCfCheck ? NoCfCheckMask : 0) |
           (cmseNSCall ? CmseNSCallMask : 0);
  }

  // Constructor with all defaults. Use when for example creating a
  // function known to use defaults.
  ExtInfo() = default;

  // Constructor with just the calling convention, which is an important part
  // of the canonical type.
  ExtInfo(CallingConv CC) : Bits(CC) {}

  bool getNoReturn() const { return Bits & NoReturnMask; }
  bool getProducesResult() const { return Bits & ProducesResultMask; }
  bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
    if (RegParm > 0)
      --RegParm;
    return RegParm;
  }

  CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }

  bool operator==(ExtInfo Other) const {
    return Bits == Other.Bits;
  }
  bool operator!=(ExtInfo Other) const {
    return Bits != Other.Bits;
  }

  // Note that we don't have setters. That is by design, use
  // the following with methods instead of mutating these objects.

  ExtInfo withNoReturn(bool noReturn) const {
    if (noReturn)
      return ExtInfo(Bits | NoReturnMask);
    else
      return ExtInfo(Bits & ~NoReturnMask);
  }

  ExtInfo withProducesResult(bool producesResult) const {
    if (producesResult)
      return ExtInfo(Bits | ProducesResultMask);
    else
      return ExtInfo(Bits & ~ProducesResultMask);
  }

  ExtInfo withCmseNSCall(bool cmseNSCall) const {
    if (cmseNSCall)
      return ExtInfo(Bits | CmseNSCallMask);
    else
      return ExtInfo(Bits & ~CmseNSCallMask);
  }

  ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
    if (noCallerSavedRegs)
      return ExtInfo(Bits | NoCallerSavedRegsMask);
    else
      return ExtInfo(Bits & ~NoCallerSavedRegsMask);
  }

  ExtInfo withNoCfCheck(bool noCfCheck) const {
    if (noCfCheck)
      return ExtInfo(Bits | NoCfCheckMask);
    else
      return ExtInfo(Bits & ~NoCfCheckMask);
  }

  ExtInfo withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")((void)0);
    return ExtInfo((Bits & ~RegParmMask) |
                   ((RegParm + 1) << RegParmOffset));
  }

  ExtInfo withCallingConv(CallingConv cc) const {
    return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
  }

  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.AddInteger(Bits);
  }
};

/// A simple holder for a QualType representing a type in an
/// exception specification. Unfortunately needed by FunctionProtoType
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };

/// A simple holder for various uncommon bits which do not fit in
/// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
/// alignment of subsequent objects in TrailingObjects. You must update
/// hasExtraBitfields in FunctionProtoType after adding extra data here.
struct alignas(void *) FunctionTypeExtraBitfields {
  /// The number of types in the exception specification.
  /// A whole unsigned is not needed here and according to
  /// [implimits] 8 bits would be enough here.
  unsigned NumExceptionType;
};

3799protected:
FunctionType(TypeClass tc, QualType res, QualType Canonical,
             TypeDependence Dependence, ExtInfo Info)
    : Type(tc, Canonical, Dependence), ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3810public:
QualType getReturnType() const { return ResultType; }

bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
unsigned getRegParmType() const { return getExtInfo().getRegParm(); }

/// Determine whether this function type includes the GNU noreturn
/// attribute. The C++11 [[noreturn]] attribute does not affect the function
/// type.
bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }

bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
CallingConv getCallConv() const { return getExtInfo().getCC(); }
ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }

static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
              "Const, volatile and restrict are assumed to be a subset of "
              "the fast qualifiers.");

bool isConst() const { return getFastTypeQuals().hasConst(); }
bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }

/// Determine the type of an expression that calls a function of
/// this type.
QualType getCallResultType(const ASTContext &Context) const {
  return getReturnType().getNonLValueExprType(Context);
}

static StringRef getNameForCallConv(CallingConv CC);

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto ||
         T->getTypeClass() == FunctionProto;
}
3845};

3847/// Represents a K&R-style 'int foo()' function, which has
3848/// no information available about its arguments.
3849class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   Result->getDependence() &
                       ~(TypeDependence::DependentInstantiation |
                         TypeDependence::UnexpandedPack),
                   Info) {}

3859public:
// No additional state past what FunctionType provides.

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReturnType(), getExtInfo());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
                    ExtInfo Info) {
  Info.Profile(ID);
  ID.AddPointer(ResultType.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto;
}
3878};

3880/// Represents a prototype with parameter type info, e.g.
3881/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3882/// parameters, not as having a single void parameter. Such a type can have
3883/// an exception specification, but this specification is not part of the
3884/// canonical type. FunctionProtoType has several trailing objects, some of
3885/// which optional. For more information about the trailing objects see
3886/// the first comment inside FunctionProtoType.
3887class FunctionProtoType final
  : public FunctionType,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<
        FunctionProtoType, QualType, SourceLocation,
        FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
        Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

// FunctionProtoType is followed by several trailing objects, some of
// which optional. They are in order:
//
// * An array of getNumParams() QualType holding the parameter types.
//   Always present. Note that for the vast majority of FunctionProtoType,
//   these will be the only trailing objects.
//
// * Optionally if the function is variadic, the SourceLocation of the
//   ellipsis.
//
// * Optionally if some extra data is stored in FunctionTypeExtraBitfields
//   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
//   a single FunctionTypeExtraBitfields. Present if and only if
//   hasExtraBitfields() is true.
//
// * Optionally exactly one of:
//   * an array of getNumExceptions() ExceptionType,
//   * a single Expr *,
//   * a pair of FunctionDecl *,
//   * a single FunctionDecl *
//   used to store information about the various types of exception
//   specification. See getExceptionSpecSize for the details.
//
// * Optionally an array of getNumParams() ExtParameterInfo holding
//   an ExtParameterInfo for each of the parameters. Present if and
//   only if hasExtParameterInfos() is true.
//
// * Optionally a Qualifiers object to represent extra qualifiers that can't
//   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
//   if hasExtQualifiers() is true.
//
// The optional FunctionTypeExtraBitfields has to be before the data
// related to the exception specification since it contains the number
// of exception types.
//
// We put the ExtParameterInfos last.  If all were equal, it would make
// more sense to put these before the exception specification, because
// it's much easier to skip past them compared to the elaborate switch
// required to skip the exception specification.  However, all is not
// equal; ExtParameterInfos are used to model very uncommon features,
// and it's better not to burden the more common paths.

3939public:
/// Holds information about the various types of exception specification.
/// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
/// used to group together the various bits of information about the
/// exception specification.
struct ExceptionSpecInfo {
  /// The kind of exception specification this is.
  ExceptionSpecificationType Type = EST_None;

  /// Explicitly-specified list of exception types.
  ArrayRef<QualType> Exceptions;

  /// Noexcept expression, if this is a computed noexcept specification.
  Expr *NoexceptExpr = nullptr;

  /// The function whose exception specification this is, for
  /// EST_Unevaluated and EST_Uninstantiated.
  FunctionDecl *SourceDecl = nullptr;

  /// The function template whose exception specification this is instantiated
  /// from, for EST_Uninstantiated.
  FunctionDecl *SourceTemplate = nullptr;

  ExceptionSpecInfo() = default;

  ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
};

/// Extra information about a function prototype. ExtProtoInfo is not
/// stored as such in FunctionProtoType but is used to group together
/// the various bits of extra information about a function prototype.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  Qualifiers TypeQuals;
  RefQualifierKind RefQualifier = RQ_None;
  ExceptionSpecInfo ExceptionSpec;
  const ExtParameterInfo *ExtParameterInfos = nullptr;
  SourceLocation EllipsisLoc;

  ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo(CallingConv CC)
      : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = ESI;
    return Result;
  }
};

3992private:
unsigned numTrailingObjects(OverloadToken<QualType>) const {
  return getNumParams();
}

unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
  return isVariadic();
}

unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
  return hasExtraBitfields();
}

unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
  return getExceptionSpecSize().NumExceptionType;
}

unsigned numTrailingObjects(OverloadToken<Expr *>) const {
  return getExceptionSpecSize().NumExprPtr;
}

unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
  return getExceptionSpecSize().NumFunctionDeclPtr;
}

unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
  return hasExtParameterInfos() ? getNumParams() : 0;
}

/// Determine whether there are any argument types that
/// contain an unexpanded parameter pack.
static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
                                               unsigned numArgs) {
  for (unsigned Idx = 0; Idx < numArgs; ++Idx)
    if (ArgArray[Idx]->containsUnexpandedParameterPack())
      return true;

  return false;
}

FunctionProtoType(QualType result, ArrayRef<QualType> params,
                  QualType canonical, const ExtProtoInfo &epi);

/// This struct is returned by getExceptionSpecSize and is used to
/// translate an ExceptionSpecificationType to the number and kind
/// of trailing objects related to the exception specification.
struct ExceptionSpecSizeHolder {
  unsigned NumExceptionType;
  unsigned NumExprPtr;
  unsigned NumFunctionDeclPtr;
};

/// Return the number and kind of trailing objects
/// related to the exception specification.
static ExceptionSpecSizeHolder
getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
  switch (EST) {
  case EST_None:
  case EST_DynamicNone:
  case EST_MSAny:
  case EST_BasicNoexcept:
  case EST_Unparsed:
  case EST_NoThrow:
    return {0, 0, 0};

  case EST_Dynamic:
    return {NumExceptions, 0, 0};

  case EST_DependentNoexcept:
  case EST_NoexceptFalse:
  case EST_NoexceptTrue:
    return {0, 1, 0};

  case EST_Uninstantiated:
    return {0, 0, 2};

  case EST_Unevaluated:
    return {0, 0, 1};
  }
  llvm_unreachable("bad exception specification kind")__builtin_unreachable();
}

/// Return the number and kind of trailing objects
/// related to the exception specification.
ExceptionSpecSizeHolder getExceptionSpecSize() const {
  return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
static bool hasExtraBitfields(ExceptionSpecificationType EST) {
  // If the exception spec type is EST_Dynamic then we have > 0 exception
  // types and the exact number is stored in FunctionTypeExtraBitfields.
  return EST == EST_Dynamic;
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
bool hasExtraBitfields() const {
  return hasExtraBitfields(getExceptionSpecType());
}

bool hasExtQualifiers() const {
  return FunctionTypeBits.HasExtQuals;
}

4096public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((void)0);
  return param_type_begin()[i];
}

ArrayRef<QualType> getParamTypes() const {
  return llvm::makeArrayRef(param_type_begin(), param_type_end());
}

ExtProtoInfo getExtProtoInfo() const {
  ExtProtoInfo EPI;
  EPI.ExtInfo = getExtInfo();
  EPI.Variadic = isVariadic();
  EPI.EllipsisLoc = getEllipsisLoc();
  EPI.HasTrailingReturn = hasTrailingReturn();
  EPI.ExceptionSpec = getExceptionSpecInfo();
  EPI.TypeQuals = getMethodQuals();
  EPI.RefQualifier = getRefQualifier();
  EPI.ExtParameterInfos = getExtParameterInfosOrNull();
  return EPI;
}

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

/// Return whether this function has any kind of exception spec.
bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }

/// Return whether this function has a dynamic (throw) exception spec.
bool hasDynamicExceptionSpec() const {
  return isDynamicExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a noexcept exception spec.
bool hasNoexceptExceptionSpec() const {
  return isNoexceptExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a dependent exception spec.
bool hasDependentExceptionSpec() const;

/// Return whether this function has an instantiation-dependent exception
/// spec.
bool hasInstantiationDependentExceptionSpec() const;

/// Return all the available information about this type's exception spec.
ExceptionSpecInfo getExceptionSpecInfo() const {
  ExceptionSpecInfo Result;
  Result.Type = getExceptionSpecType();
  if (Result.Type == EST_Dynamic) {
    Result.Exceptions = exceptions();
  } else if (isComputedNoexcept(Result.Type)) {
    Result.NoexceptExpr = getNoexceptExpr();
  } else if (Result.Type == EST_Uninstantiated) {
    Result.SourceDecl = getExceptionSpecDecl();
    Result.SourceTemplate = getExceptionSpecTemplate();
  } else if (Result.Type == EST_Unevaluated) {
    Result.SourceDecl = getExceptionSpecDecl();
  }
  return Result;
}

/// Return the number of types in the exception specification.
unsigned getNumExceptions() const {
  return getExceptionSpecType() == EST_Dynamic
             ? getTrailingObjects<FunctionTypeExtraBitfields>()
                   ->NumExceptionType
             : 0;
}

/// Return the ith exception type, where 0 <= i < getNumExceptions().
QualType getExceptionType(unsigned i) const {
  assert(i < getNumExceptions() && "Invalid exception number!")((void)0);
  return exception_begin()[i];
}

/// Return the expression inside noexcept(expression), or a null pointer
/// if there is none (because the exception spec is not of this form).
Expr *getNoexceptExpr() const {
  if (!isComputedNoexcept(getExceptionSpecType()))
    return nullptr;
  return *getTrailingObjects<Expr *>();
}

/// If this function type has an exception specification which hasn't
/// been determined yet (either because it has not been evaluated or because
/// it has not been instantiated), this is the function whose exception
/// specification is represented by this type.
FunctionDecl *getExceptionSpecDecl() const {
  if (getExceptionSpecType() != EST_Uninstantiated &&
      getExceptionSpecType() != EST_Unevaluated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[0];
}

/// If this function type has an uninstantiated exception
/// specification, this is the function whose exception specification
/// should be instantiated to find the exception specification for
/// this type.
FunctionDecl *getExceptionSpecTemplate() const {
  if (getExceptionSpecType() != EST_Uninstantiated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow() const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
}

/// Whether this function prototype is variadic.
bool isVariadic() const { return FunctionTypeBits.Variadic; }

SourceLocation getEllipsisLoc() const {
  return isVariadic() ? *getTrailingObjects<SourceLocation>()
                      : SourceLocation();
}

/// Determines whether this function prototype contains a
/// parameter pack at the end.
///
/// A function template whose last parameter is a parameter pack can be
/// called with an arbitrary number of arguments, much like a variadic
/// function.
bool isTemplateVariadic() const;

/// Whether this function prototype has a trailing return type.
bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }

Qualifiers getMethodQuals() const {
  if (hasExtQualifiers())
    return *getTrailingObjects<Qualifiers>();
  else
    return getFastTypeQuals();
}

/// Retrieve the ref-qualifier associated with this function type.
RefQualifierKind getRefQualifier() const {
  return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
}

using param_type_iterator = const QualType *;
using param_type_range = llvm::iterator_range<param_type_iterator>;

param_type_range param_types() const {
  return param_type_range(param_type_begin(), param_type_end());
}

param_type_iterator param_type_begin() const {
  return getTrailingObjects<QualType>();
}

param_type_iterator param_type_end() const {
  return param_type_begin() + getNumParams();
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  return reinterpret_cast<exception_iterator>(
      getTrailingObjects<ExceptionType>());
}

exception_iterator exception_end() const {
  return exception_begin() + getNumExceptions();
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const {
  return FunctionTypeBits.HasExtParameterInfos;
}

ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())((void)0);
  return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
                                    getNumParams());
}

/// Return a pointer to the beginning of the array of extra parameter
/// information, if present, or else null if none of the parameters
/// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
const ExtParameterInfo *getExtParameterInfosOrNull() const {
  if (!hasExtParameterInfos())
    return nullptr;
  return getTrailingObjects<ExtParameterInfo>();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void printExceptionSpecification(raw_ostream &OS,
                                 const PrintingPolicy &Policy) const;

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionProto;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                    param_type_iterator ArgTys, unsigned NumArgs,
                    const ExtProtoInfo &EPI, const ASTContext &Context,
                    bool Canonical);
4336};

4338/// Represents the dependent type named by a dependently-scoped
4339/// typename using declaration, e.g.
4340///   using typename Base<T>::foo;
4341///
4342/// Template instantiation turns these into the underlying type.
4343class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}

4353public:
UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnresolvedUsing;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  return Profile(ID, Decl);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    UnresolvedUsingTypenameDecl *D) {
  ID.AddPointer(D);
}
4371};

4373class TypedefType : public Type {
TypedefNameDecl *Decl;

4376private:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
            QualType can);

4382public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4389};

4391/// Sugar type that represents a type that was qualified by a qualifier written
4392/// as a macro invocation.
4393class MacroQualifiedType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType UnderlyingTy;
const IdentifierInfo *MacroII;

MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
                   const IdentifierInfo *MacroII)
    : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&((void)0)
         "Expected a macro qualified type to only wrap attributed types.")((void)0);
}

4407public:
const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
QualType getUnderlyingType() const { return UnderlyingTy; }

/// Return this attributed type's modified type with no qualifiers attached to
/// it.
QualType getModifiedType() const;

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == MacroQualified;
}
4421};

4423/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4424class TypeOfExprType : public Type {
Expr *TOExpr;

4427protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4432public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4442};

4444/// Internal representation of canonical, dependent
4445/// `typeof(expr)` types.
4446///
4447/// This class is used internally by the ASTContext to manage
4448/// canonical, dependent types, only. Clients will only see instances
4449/// of this class via TypeOfExprType nodes.
4450class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4454public:
DependentTypeOfExprType(const ASTContext &Context, Expr *E)
    : TypeOfExprType(E), Context(Context) {}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4464};

4466/// Represents `typeof(type)`, a GCC extension.
4467class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->getDependence()), TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((void)0);
}

4477public:
QualType getUnderlyingType() const { return TOType; }

/// Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4487};

4489/// Represents the type `decltype(expr)` (C++11).
4490class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4494protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4499public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4510};

4512/// Internal representation of canonical, dependent
4513/// decltype(expr) types.
4514///
4515/// This class is used internally by the ASTContext to manage
4516/// canonical, dependent types, only. Clients will only see instances
4517/// of this class via DecltypeType nodes.
4518class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4521public:
DependentDecltypeType(const ASTContext &Context, Expr *E);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4530};

4532/// A unary type transform, which is a type constructed from another.
4533class UnaryTransformType : public Type {
4534public:
enum UTTKind {
  EnumUnderlyingType
};

4539private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4548protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4554public:
bool isSugared() const { return !isDependentType(); }
QualType desugar() const { return UnderlyingType; }

QualType getUnderlyingType() const { return UnderlyingType; }
QualType getBaseType() const { return BaseType; }

UTTKind getUTTKind() const { return UKind; }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnaryTransform;
}
4566};

4568/// Internal representation of canonical, dependent
4569/// __underlying_type(type) types.
4570///
4571/// This class is used internally by the ASTContext to manage
4572/// canonical, dependent types, only. Clients will only see instances
4573/// of this class via UnaryTransformType nodes.
4574class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4576public:
DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
                            UTTKind UKind);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getBaseType(), getUTTKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                    UTTKind UKind) {
  ID.AddPointer(BaseType.getAsOpaquePtr());
  ID.AddInteger((unsigned)UKind);
}
4589};

4591class TagType : public Type {
friend class ASTReader;
template <class T> friend class serialization::AbstractTypeReader;

/// Stores the TagDecl associated with this type. The decl may point to any
/// TagDecl that declares the entity.
TagDecl *decl;

4599protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4602public:
TagDecl *getDecl() const;

/// Determines whether this type is in the process of being defined.
bool isBeingDefined() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == Enum || T->getTypeClass() == Record;
}
4611};

4613/// A helper class that allows the use of isa/cast/dyncast
4614/// to detect TagType objects of structs/unions/classes.
4615class RecordType : public TagType {
4616protected:
friend class ASTContext; // ASTContext creates these.

explicit RecordType(const RecordDecl *D)
    : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
explicit RecordType(TypeClass TC, RecordDecl *D)
    : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4624public:
RecordDecl *getDecl() const {
  return reinterpret_cast<RecordDecl*>(TagType::getDecl());
}

/// Recursively check all fields in the record for const-ness. If any field
/// is declared const, return true. Otherwise, return false.
bool hasConstFields() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4637};

4639/// A helper class that allows the use of isa/cast/dyncast
4640/// to detect TagType objects of enums.
4641class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4647public:
EnumDecl *getDecl() const {
  return reinterpret_cast<EnumDecl*>(TagType::getDecl());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4656};

4658/// An attributed type is a type to which a type attribute has been applied.
4659///
4660/// The "modified type" is the fully-sugared type to which the attributed
4661/// type was applied; generally it is not canonically equivalent to the
4662/// attributed type. The "equivalent type" is the minimally-desugared type
4663/// which the type is canonically equivalent to.
4664///
4665/// For example, in the following attributed type:
4666///     int32_t __attribute__((vector_size(16)))
4667///   - the modified type is the TypedefType for int32_t
4668///   - the equivalent type is VectorType(16, int32_t)
4669///   - the canonical type is VectorType(16, int)
4670class AttributedType : public Type, public llvm::FoldingSetNode {
4671public:
using Kind = attr::Kind;

4674private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->getDependence()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4687public:
Kind getAttrKind() const {
  return static_cast<Kind>(AttributedTypeBits.AttrKind);
}

QualType getModifiedType() const { return ModifiedType; }
QualType getEquivalentType() const { return EquivalentType; }

bool isSugared() const { return true; }
QualType desugar() const { return getEquivalentType(); }

/// Does this attribute behave like a type qualifier?
///
/// A type qualifier adjusts a type to provide specialized rules for
/// a specific object, like the standard const and volatile qualifiers.
/// This includes attributes controlling things like nullability,
/// address spaces, and ARC ownership.  The value of the object is still
/// largely described by the modified type.
///
/// In contrast, many type attributes "rewrite" their modified type to
/// produce a fundamentally different type, not necessarily related in any
/// formalizable way to the original type.  For example, calling convention
/// and vector attributes are not simple type qualifiers.
///
/// Type qualifiers are often, but not always, reflected in the canonical
/// type.
bool isQualifier() const;

bool isMSTypeSpec() const;

bool isCallingConv() const;

llvm::Optional<NullabilityKind> getImmediateNullability() const;

/// Retrieve the attribute kind corresponding to the given
/// nullability kind.
static Kind getNullabilityAttrKind(NullabilityKind kind) {
  switch (kind) {
  case NullabilityKind::NonNull:
    return attr::TypeNonNull;

  case NullabilityKind::Nullable:
    return attr::TypeNullable;

  case NullabilityKind::NullableResult:
    return attr::TypeNullableResult;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
}

/// Strip off the top-level nullability annotation on the given
/// type, if it's there.
///
/// \param T The type to strip. If the type is exactly an
/// AttributedType specifying nullability (without looking through
/// type sugar), the nullability is returned and this type changed
/// to the underlying modified type.
///
/// \returns the top-level nullability, if present.
static Optional<NullabilityKind> stripOuterNullability(QualType &T);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
}

static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
                    QualType modified, QualType equivalent) {
  ID.AddInteger(attrKind);
  ID.AddPointer(modified.getAsOpaquePtr());
  ID.AddPointer(equivalent.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}
4765};

4767class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

// Helper data collector for canonical types.
struct CanonicalTTPTInfo {
  unsigned Depth : 15;
  unsigned ParameterPack : 1;
  unsigned Index : 16;
};

union {
  // Info for the canonical type.
  CanonicalTTPTInfo CanTTPTInfo;

  // Info for the non-canonical type.
  TemplateTypeParmDecl *TTPDecl;
};

/// Build a non-canonical type.
TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
    : Type(TemplateTypeParm, Canon,
           TypeDependence::DependentInstantiation |
               (Canon->getDependence() & TypeDependence::UnexpandedPack)),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           TypeDependence::DependentInstantiation |
               (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4807public:
unsigned getDepth() const { return getCanTTPTInfo().Depth; }
unsigned getIndex() const { return getCanTTPTInfo().Index; }
bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }

TemplateTypeParmDecl *getDecl() const {
  return isCanonicalUnqualified() ? nullptr : TTPDecl;
}

IdentifierInfo *getIdentifier() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
                    unsigned Index, bool ParameterPack,
                    TemplateTypeParmDecl *TTPDecl) {
  ID.AddInteger(Depth);
  ID.AddInteger(Index);
  ID.AddBoolean(ParameterPack);
  ID.AddPointer(TTPDecl);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateTypeParm;
}
4837};

4839/// Represents the result of substituting a type for a template
4840/// type parameter.
4841///
4842/// Within an instantiated template, all template type parameters have
4843/// been replaced with these.  They are used solely to record that a
4844/// type was originally written as a template type parameter;
4845/// therefore they are never canonical.
4846class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

// The original type parameter.
const TemplateTypeParmType *Replaced;

SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
    : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
      Replaced(Param) {}

4856public:
/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

/// Gets the type that was substituted for the template
/// parameter.
QualType getReplacementType() const {
  return getCanonicalTypeInternal();
}

bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReplacedParameter(), getReplacementType());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    QualType Replacement) {
  ID.AddPointer(Replaced);
  ID.AddPointer(Replacement.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParm;
}
4885};

4887/// Represents the result of substituting a set of types for a template
4888/// type parameter pack.
4889///
4890/// When a pack expansion in the source code contains multiple parameter packs
4891/// and those parameter packs correspond to different levels of template
4892/// parameter lists, this type node is used to represent a template type
4893/// parameter pack from an outer level, which has already had its argument pack
4894/// substituted but that still lives within a pack expansion that itself
4895/// could not be instantiated. When actually performing a substitution into
4896/// that pack expansion (e.g., when all template parameters have corresponding
4897/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4898/// at the current pack substitution index.
4899class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// The original type parameter.
const TemplateTypeParmType *Replaced;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4913public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

unsigned getNumArgs() const {
  return SubstTemplateTypeParmPackTypeBits.NumArgs;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

TemplateArgument getArgumentPack() const;

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    const TemplateArgument &ArgPack);

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParmPack;
}
4938};

4940/// Common base class for placeholders for types that get replaced by
4941/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4942/// class template types, and constrained type names.
4943///
4944/// These types are usually a placeholder for a deduced type. However, before
4945/// the initializer is attached, or (usually) if the initializer is
4946/// type-dependent, there is no deduced type and the type is canonical. In
4947/// the latter case, it is also a dependent type.
4948class DeducedType : public Type {
4949protected:
DeducedType(TypeClass TC, QualType DeducedAsType,
            TypeDependence ExtraDependence)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           ExtraDependence | (DeducedAsType.isNull()
                                  ? TypeDependence::None
                                  : DeducedAsType->getDependence() &
                                        ~TypeDependence::VariablyModified)) {}

4961public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// Get the type deduced for this placeholder type, or null if it's
/// either not been deduced or was deduced to a dependent type.
QualType getDeducedType() const {
  return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
}
bool isDeduced() const {
  return !isCanonicalUnqualified() || isDependentType();
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto ||
         T->getTypeClass() == DeducedTemplateSpecialization;
}
4978};

4980/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4981/// by a type-constraint.
4982class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

ConceptDecl *TypeConstraintConcept;

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         TypeDependence ExtraDependence, ConceptDecl *CD,
         ArrayRef<TemplateArgument> TypeConstraintArgs);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

4999public:
/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return AutoTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
  return {getArgs(), getNumArgs()};
}

ConceptDecl *getTypeConstraintConcept() const {
  return TypeConstraintConcept;
}

bool isConstrained() const {
  return TypeConstraintConcept != nullptr;
}

bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
          getTypeConstraintConcept(), getTypeConstraintArguments());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType Deduced, AutoTypeKeyword Keyword,
                    bool IsDependent, ConceptDecl *CD,
                    ArrayRef<TemplateArgument> Arguments);

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
5045};

5047/// Represents a C++17 deduced template specialization type.
5048class DeducedTemplateSpecializationType : public DeducedType,
                                        public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template whose arguments will be deduced.
TemplateName Template;

DeducedTemplateSpecializationType(TemplateName Template,
                                  QualType DeducedAsType,
                                  bool IsDeducedAsDependent)
    : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                  toTypeDependence(Template.getDependence()) |
                      (IsDeducedAsDependent
                           ? TypeDependence::DependentInstantiation
                           : TypeDependence::None)),
      Template(Template) {}

5065public:
/// Retrieve the name of the template that we are deducing.
TemplateName getTemplateName() const { return Template;}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
                    QualType Deduced, bool IsDependent) {
  Template.Profile(ID);
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DeducedTemplateSpecialization;
}
5083};

5085/// Represents a type template specialization; the template
5086/// must be a class template, a type alias template, or a template
5087/// template parameter.  A template which cannot be resolved to one of
5088/// these, e.g. because it is written with a dependent scope
5089/// specifier, is instead represented as a
5090/// @c DependentTemplateSpecializationType.
5091///
5092/// A non-dependent template specialization type is always "sugar",
5093/// typically for a \c RecordType.  For example, a class template
5094/// specialization type of \c vector<int> will refer to a tag type for
5095/// the instantiation \c std::vector<int, std::allocator<int>>
5096///
5097/// Template specializations are dependent if either the template or
5098/// any of the template arguments are dependent, in which case the
5099/// type may also be canonical.
5100///
5101/// Instances of this type are allocated with a trailing array of
5102/// TemplateArguments, followed by a QualType representing the
5103/// non-canonical aliased type when the template is a type alias
5104/// template.
5105class alignas(8) TemplateSpecializationType
  : public Type,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template being specialized.  This is
/// either a TemplateName::Template (in which case it is a
/// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
/// TypeAliasTemplateDecl*), a
/// TemplateName::SubstTemplateTemplateParmPack, or a
/// TemplateName::SubstTemplateTemplateParm (in which case the
/// replacement must, recursively, be one of these).
TemplateName Template;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

5124public:
/// Determine whether any of the given template arguments are dependent.
///
/// The converted arguments should be supplied when known; whether an
/// argument is dependent can depend on the conversions performed on it
/// (for example, a 'const int' passed as a template argument might be
/// dependent if the parameter is a reference but non-dependent if the
/// parameter is an int).
///
/// Note that the \p Args parameter is unused: this is intentional, to remind
/// the caller that they need to pass in the converted arguments, not the
/// specified arguments.
static bool
anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                              ArrayRef<TemplateArgument> Converted);
static bool
anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                              ArrayRef<TemplateArgument> Converted);
static bool anyInstantiationDependentTemplateArguments(
    ArrayRef<TemplateArgumentLoc> Args);

/// True if this template specialization type matches a current
/// instantiation in the context in which it is found.
bool isCurrentInstantiation() const {
  return isa<InjectedClassNameType>(getCanonicalTypeInternal());
}

/// Determine if this template specialization type is for a type alias
/// template that has been substituted.
///
/// Nearly every template specialization type whose template is an alias
/// template will be substituted. However, this is not the case when
/// the specialization contains a pack expansion but the template alias
/// does not have a corresponding parameter pack, e.g.,
///
/// \code
/// template<typename T, typename U, typename V> struct S;
/// template<typename T, typename U> using A = S<T, int, U>;
/// template<typename... Ts> struct X {
///   typedef A<Ts...> type; // not a type alias
/// };
/// \endcode
bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }

/// Get the aliased type, if this is a specialization of a type alias
/// template.
QualType getAliasedType() const {
  assert(isTypeAlias() && "not a type alias template specialization")((void)0);
  return *reinterpret_cast<const QualType*>(end());
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // defined inline in TemplateBase.h

/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return reinterpret_cast<const TemplateArgument *>(this + 1);
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return TemplateSpecializationTypeBits.NumArgs;
}

/// Retrieve a specific template argument as a type.
/// \pre \c isArgType(Arg)
const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const {
  return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Template, template_arguments(), Ctx);
  if (isTypeAlias())
    getAliasedType().Profile(ID);
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                    ArrayRef<TemplateArgument> Args,
                    const ASTContext &Context);

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateSpecialization;
}
5222};

5224/// Print a template argument list, including the '<' and '>'
5225/// enclosing the template arguments.
5226void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5231void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5236void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5241/// The injected class name of a C++ class template or class
5242/// template partial specialization.  Used to record that a type was
5243/// spelled with a bare identifier rather than as a template-id; the
5244/// equivalent for non-templated classes is just RecordType.
5245///
5246/// Injected class name types are always dependent.  Template
5247/// instantiation turns these into RecordTypes.
5248///
5249/// Injected class name types are always canonical.  This works
5250/// because it is impossible to compare an injected class name type
5251/// with the corresponding non-injected template type, for the same
5252/// reason that it is impossible to directly compare template
5253/// parameters from different dependent contexts: injected class name
5254/// types can only occur within the scope of a particular templated
5255/// declaration, and within that scope every template specialization
5256/// will canonicalize to the injected class name (when appropriate
5257/// according to the rules of the language).
5258class InjectedClassNameType : public Type {
friend class ASTContext; // ASTContext creates these.
friend class ASTNodeImporter;
friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                        // currently suitable for AST reading, too much
                        // interdependencies.
template <class T> friend class serialization::AbstractTypeReader;

CXXRecordDecl *Decl;

/// The template specialization which this type represents.
/// For example, in
///   template <class T> class A { ... };
/// this is A<T>, whereas in
///   template <class X, class Y> class A<B<X,Y> > { ... };
/// this is A<B<X,Y> >.
///
/// It is always unqualified, always a template specialization type,
/// and always dependent.
QualType InjectedType;

InjectedClassNameType(CXXRecordDecl *D, QualType TST)
    : Type(InjectedClassName, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))((void)0);
  assert(!TST.hasQualifiers())((void)0);
  assert(TST->isDependentType())((void)0);
}

5288public:
QualType getInjectedSpecializationType() const { return InjectedType; }

const TemplateSpecializationType *getInjectedTST() const {
  return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
}

TemplateName getTemplateName() const {
  return getInjectedTST()->getTemplateName();
}

CXXRecordDecl *getDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == InjectedClassName;
}
5307};

5309/// The kind of a tag type.
5310enum TagTypeKind {
/// The "struct" keyword.
TTK_Struct,

/// The "__interface" keyword.
TTK_Interface,

/// The "union" keyword.
TTK_Union,

/// The "class" keyword.
TTK_Class,

/// The "enum" keyword.
TTK_Enum
5325};

5327/// The elaboration keyword that precedes a qualified type name or
5328/// introduces an elaborated-type-specifier.
5329enum ElaboratedTypeKeyword {
/// The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// No keyword precedes the qualified type name.
ETK_None
5351};

5353/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5354/// The keyword in stored in the free bits of the base class.
5355/// Also provides a few static helpers for converting and printing
5356/// elaborated type keyword and tag type kind enumerations.
5357class TypeWithKeyword : public Type {
5358protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, TypeDependence Dependence)
    : Type(tc, Canonical, Dependence) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5365public:
ElaboratedTypeKeyword getKeyword() const {
  return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
}

/// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);

/// Converts a type specifier (DeclSpec::TST) into a tag type kind.
/// It is an error to provide a type specifier which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);

/// Converts a TagTypeKind into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);

/// Converts an elaborated type keyword into a TagTypeKind.
/// It is an error to provide an elaborated type keyword
/// which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);

static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);

static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);

static StringRef getTagTypeKindName(TagTypeKind Kind) {
  return getKeywordName(getKeywordForTagTypeKind(Kind));
}

class CannotCastToThisType {};
static CannotCastToThisType classof(const Type *);
5395};

5397/// Represents a type that was referred to using an elaborated type
5398/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5399/// or both.
5400///
5401/// This type is used to keep track of a type name as written in the
5402/// source code, including tag keywords and any nested-name-specifiers.
5403/// The type itself is always "sugar", used to express what was written
5404/// in the source code but containing no additional semantic information.
5405class ElaboratedType final
  : public TypeWithKeyword,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
friend class ASTContext; // ASTContext creates these
friend TrailingObjects;

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

/// The (re)declaration of this tag type owned by this occurrence is stored
/// as a trailing object if there is one. Use getOwnedTagDecl to obtain
/// it, or obtain a null pointer if there is none.

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
    : TypeWithKeyword(Keyword, Elaborated, CanonType,
                      // Any semantic dependence on the qualifier will have
                      // been incorporated into NamedType. We still need to
                      // track syntactic (instantiation / error / pack)
                      // dependence on the qualifier.
                      NamedType->getDependence() |
                          (NNS ? toSyntacticDependence(
                                     toTypeDependence(NNS->getDependence()))
                               : TypeDependence::None)),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&((void)0)
         "ElaboratedType cannot have elaborated type keyword "((void)0)
         "and name qualifier both null.")((void)0);
}

5444public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the qualified-id.
QualType getNamedType() const { return NamedType; }

/// Remove a single level of sugar.
QualType desugar() const { return getNamedType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if there is none.
TagDecl *getOwnedTagDecl() const {
  return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
                                            : nullptr;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType,
                    TagDecl *OwnedTagDecl) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
  ID.AddPointer(OwnedTagDecl);
}

static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5478};

5480/// Represents a qualified type name for which the type name is
5481/// dependent.
5482///
5483/// DependentNameType represents a class of dependent types that involve a
5484/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5485/// name of a type. The DependentNameType may start with a "typename" (for a
5486/// typename-specifier), "class", "struct", "union", or "enum" (for a
5487/// dependent elaborated-type-specifier), or nothing (in contexts where we
5488/// know that we must be referring to a type, e.g., in a base class specifier).
5489/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5490/// mode, this type is used with non-dependent names to delay name lookup until
5491/// instantiation.
5492class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this typename specifier refers to.
const IdentifierInfo *Name;

DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
                  const IdentifierInfo *Name, QualType CanonType)
    : TypeWithKeyword(Keyword, DependentName, CanonType,
                      TypeDependence::DependentInstantiation |
                          toTypeDependence(NNS->getDependence())),
      NNS(NNS), Name(Name) {}

5508public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the typename specifier as an identifier.
///
/// This routine will return a non-NULL identifier pointer when the
/// form of the original typename was terminated by an identifier,
/// e.g., "typename T::type".
const IdentifierInfo *getIdentifier() const {
  return Name;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, Name);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  ID.AddPointer(Name);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentName;
}
5538};

5540/// Represents a template specialization type whose template cannot be
5541/// resolved, e.g.
5542///   A<T>::template B<T>
5543class alignas(8) DependentTemplateSpecializationType
  : public TypeWithKeyword,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The identifier of the template.
const IdentifierInfo *Name;

DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                    NestedNameSpecifier *NNS,
                                    const IdentifierInfo *Name,
                                    ArrayRef<TemplateArgument> Args,
                                    QualType Canon);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

5568public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return DependentTemplateSpecializationTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // inline in TemplateBase.h

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const ASTContext &Context,
                    ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *Qualifier,
                    const IdentifierInfo *Name,
                    ArrayRef<TemplateArgument> Args);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentTemplateSpecialization;
}
5610};

5612/// Represents a pack expansion of types.
5613///
5614/// Pack expansions are part of C++11 variadic templates. A pack
5615/// expansion contains a pattern, which itself contains one or more
5616/// "unexpanded" parameter packs. When instantiated, a pack expansion
5617/// produces a series of types, each instantiated from the pattern of
5618/// the expansion, where the Ith instantiation of the pattern uses the
5619/// Ith arguments bound to each of the unexpanded parameter packs. The
5620/// pack expansion is considered to "expand" these unexpanded
5621/// parameter packs.
5622///
5623/// \code
5624/// template<typename ...Types> struct tuple;
5625///
5626/// template<typename ...Types>
5627/// struct tuple_of_references {
5628///   typedef tuple<Types&...> type;
5629/// };
5630/// \endcode
5631///
5632/// Here, the pack expansion \c Types&... is represented via a
5633/// PackExpansionType whose pattern is Types&.
5634class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The pattern of the pack expansion.
QualType Pattern;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon,
           (Pattern->getDependence() | TypeDependence::Dependent |
            TypeDependence::Instantiation) &
               ~TypeDependence::UnexpandedPack),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5651public:
/// Retrieve the pattern of this pack expansion, which is the
/// type that will be repeatedly instantiated when instantiating the
/// pack expansion itself.
QualType getPattern() const { return Pattern; }

/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (PackExpansionTypeBits.NumExpansions)
    return PackExpansionTypeBits.NumExpansions - 1;
  return None;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPattern(), getNumExpansions());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
                    Optional<unsigned> NumExpansions) {
  ID.AddPointer(Pattern.getAsOpaquePtr());
  ID.AddBoolean(NumExpansions.hasValue());
  if (NumExpansions)
    ID.AddInteger(*NumExpansions);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == PackExpansion;
}
5683};

5685/// This class wraps the list of protocol qualifiers. For types that can
5686/// take ObjC protocol qualifers, they can subclass this class.
5687template <class T>
5688class ObjCProtocolQualifiers {
5689protected:
ObjCProtocolQualifiers() = default;

ObjCProtocolDecl * const *getProtocolStorage() const {
  return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
}

ObjCProtocolDecl **getProtocolStorage() {
  return static_cast<T*>(this)->getProtocolStorageImpl();
}

void setNumProtocols(unsigned N) {
  static_cast<T*>(this)->setNumProtocolsImpl(N);
}

void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
  setNumProtocols(protocols.size());
  assert(getNumProtocols() == protocols.size() &&((void)0)
         "bitfield overflow in protocol count")((void)0);
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5713public:
using qual_iterator = ObjCProtocolDecl * const *;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
qual_iterator qual_begin() const { return getProtocolStorage(); }
qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }

bool qual_empty() const { return getNumProtocols() == 0; }

/// Return the number of qualifying protocols in this type, or 0 if
/// there are none.
unsigned getNumProtocols() const {
  return static_cast<const T*>(this)->getNumProtocolsImpl();
}

/// Fetch a protocol by index.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  assert(I < getNumProtocols() && "Out-of-range protocol access")((void)0);
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5739};

5741/// Represents a type parameter type in Objective C. It can take
5742/// a list of protocols.
5743class ObjCTypeParamType : public Type,
                        public ObjCProtocolQualifiers<ObjCTypeParamType>,
                        public llvm::FoldingSetNode {
friend class ASTContext;
friend class ObjCProtocolQualifiers<ObjCTypeParamType>;

/// The number of protocols stored on this type.
unsigned NumProtocols : 6;

ObjCTypeParamDecl *OTPDecl;

/// The protocols are stored after the ObjCTypeParamType node. In the
/// canonical type, the list of protocols are sorted alphabetically
/// and uniqued.
ObjCProtocolDecl **getProtocolStorageImpl();

/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return NumProtocols;
}

void setNumProtocolsImpl(unsigned N) {
  NumProtocols = N;
}

ObjCTypeParamType(const ObjCTypeParamDecl *D,
                  QualType can,
                  ArrayRef<ObjCProtocolDecl *> protocols);

5773public:
bool isSugared() const { return true; }
QualType desugar() const { return getCanonicalTypeInternal(); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCTypeParam;
}

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const ObjCTypeParamDecl *OTPDecl,
                    QualType CanonicalType,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5788};

5790/// Represents a class type in Objective C.
5791///
5792/// Every Objective C type is a combination of a base type, a set of
5793/// type arguments (optional, for parameterized classes) and a list of
5794/// protocols.
5795///
5796/// Given the following declarations:
5797/// \code
5798///   \@class C<T>;
5799///   \@protocol P;
5800/// \endcode
5801///
5802/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5803/// with base C and no protocols.
5804///
5805/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5806/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5807/// protocol list.
5808/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5809/// and protocol list [P].
5810///
5811/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5812/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5813/// and no protocols.
5814///
5815/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5816/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5817/// this should get its own sugar class to better represent the source.
5818class ObjCObjectType : public Type,
                     public ObjCProtocolQualifiers<ObjCObjectType> {
friend class ObjCProtocolQualifiers<ObjCObjectType>;

// ObjCObjectType.NumTypeArgs - the number of type arguments stored
// after the ObjCObjectPointerType node.
// ObjCObjectType.NumProtocols - the number of protocols stored
// after the type arguments of ObjCObjectPointerType node.
//
// These protocols are those written directly on the type.  If
// protocol qualifiers ever become additive, the iterators will need
// to get kindof complicated.
//
// In the canonical object type, these are sorted alphabetically
// and uniqued.

/// Either a BuiltinType or an InterfaceType or sugar for either.
QualType BaseType;

/// Cached superclass type.
mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
  CachedSuperClassType;

QualType *getTypeArgStorage();
const QualType *getTypeArgStorage() const {
  return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
}

ObjCProtocolDecl **getProtocolStorageImpl();
/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return ObjCObjectTypeBits.NumProtocols;
}
void setNumProtocolsImpl(unsigned N) {
  ObjCObjectTypeBits.NumProtocols = N;
}

5856protected:
enum Nonce_ObjCInterface { Nonce_ObjCInterface };

ObjCObjectType(QualType Canonical, QualType Base,
               ArrayRef<QualType> typeArgs,
               ArrayRef<ObjCProtocolDecl *> protocols,
               bool isKindOf);

ObjCObjectType(enum Nonce_ObjCInterface)
    : Type(ObjCInterface, QualType(), TypeDependence::None),
      BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5874public:
/// Gets the base type of this object type.  This is always (possibly
/// sugar for) one of:
///  - the 'id' builtin type (as opposed to the 'id' type visible to the
///    user, which is a typedef for an ObjCObjectPointerType)
///  - the 'Class' builtin type (same caveat)
///  - an ObjCObjectType (currently always an ObjCInterfaceType)
QualType getBaseType() const { return BaseType; }

bool isObjCId() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
}

bool isObjCClass() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
}

bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
bool isObjCUnqualifiedIdOrClass() const {
  if (!qual_empty()) return false;
  if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
    return T->getKind() == BuiltinType::ObjCId ||
           T->getKind() == BuiltinType::ObjCClass;
  return false;
}
bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }

/// Gets the interface declaration for this object type, if the base type
/// really is an interface.
ObjCInterfaceDecl *getInterface() const;

/// Determine whether this object type is "specialized", meaning
/// that it has type arguments.
bool isSpecialized() const;

/// Determine whether this object type was written with type arguments.
bool isSpecializedAsWritten() const {
  return ObjCObjectTypeBits.NumTypeArgs > 0;
}

/// Determine whether this object type is "unspecialized", meaning
/// that it has no type arguments.
bool isUnspecialized() const { return !isSpecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments of this object type (semantically).
ArrayRef<QualType> getTypeArgs() const;

/// Retrieve the type arguments of this object type as they were
/// written.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return llvm::makeArrayRef(getTypeArgStorage(),
                            ObjCObjectTypeBits.NumTypeArgs);
}

/// Whether this is a "__kindof" type as written.
bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }

/// Whether this ia a "__kindof" type (semantically).
bool isKindOfType() const;

/// Retrieve the type of the superclass of this object type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// specialization of the superclass type. Produces a null type if
/// there is no superclass.
QualType getSuperClassType() const {
  if (!CachedSuperClassType.getInt())
    computeSuperClassTypeSlow();

  assert(CachedSuperClassType.getInt() && "Superclass not set?")((void)0);
  return QualType(CachedSuperClassType.getPointer(), 0);
}

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObject ||
         T->getTypeClass() == ObjCInterface;
}
5965};

5967/// A class providing a concrete implementation
5968/// of ObjCObjectType, so as to not increase the footprint of
5969/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5970/// system should not reference this type.
5971class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
friend class ASTContext;

// If anyone adds fields here, ObjCObjectType::getProtocolStorage()
// will need to be modified.

ObjCObjectTypeImpl(QualType Canonical, QualType Base,
                   ArrayRef<QualType> typeArgs,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   bool isKindOf)
    : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}

5983public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5990};

5992inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5994}

5996inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5999}

6001inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
6004}

6006/// Interfaces are the core concept in Objective-C for object oriented design.
6007/// They basically correspond to C++ classes.  There are two kinds of interface
6008/// types: normal interfaces like `NSString`, and qualified interfaces, which
6009/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6010///
6011/// ObjCInterfaceType guarantees the following properties when considered
6012/// as a subtype of its superclass, ObjCObjectType:
6013///   - There are no protocol qualifiers.  To reinforce this, code which
6014///     tries to invoke the protocol methods via an ObjCInterfaceType will
6015///     fail to compile.
6016///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
6017///     T->getBaseType() == QualType(T, 0).
6018class ObjCInterfaceType : public ObjCObjectType {
friend class ASTContext; // ASTContext creates these.
friend class ASTReader;
friend class ObjCInterfaceDecl;
template <class T> friend class serialization::AbstractTypeReader;

mutable ObjCInterfaceDecl *Decl;

ObjCInterfaceType(const ObjCInterfaceDecl *D)
    : ObjCObjectType(Nonce_ObjCInterface),
      Decl(const_cast<ObjCInterfaceDecl*>(D)) {}

6030public:
/// Get the declaration of this interface.
ObjCInterfaceDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCInterface;
}

// Nonsense to "hide" certain members of ObjCObjectType within this
// class.  People asking for protocols on an ObjCInterfaceType are
// not going to get what they want: ObjCInterfaceTypes are
// guaranteed to have no protocols.
enum {
  qual_iterator,
  qual_begin,
  qual_end,
  getNumProtocols,
  getProtocol
};
6052};

6054inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
6064}

6066/// Represents a pointer to an Objective C object.
6067///
6068/// These are constructed from pointer declarators when the pointee type is
6069/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
6070/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6071/// and 'Class<P>' are translated into these.
6072///
6073/// Pointers to pointers to Objective C objects are still PointerTypes;
6074/// only the first level of pointer gets it own type implementation.
6075class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
      PointeeType(Pointee) {}

6084public:
/// Gets the type pointed to by this ObjC pointer.
/// The result will always be an ObjCObjectType or sugar thereof.
QualType getPointeeType() const { return PointeeType; }

/// Gets the type pointed to by this ObjC pointer.  Always returns non-null.
///
/// This method is equivalent to getPointeeType() except that
/// it discards any typedefs (or other sugar) between this
/// type and the "outermost" object type.  So for:
/// \code
///   \@class A; \@protocol P; \@protocol Q;
///   typedef A<P> AP;
///   typedef A A1;
///   typedef A1<P> A1P;
///   typedef A1P<Q> A1PQ;
/// \endcode
/// For 'A*', getObjectType() will return 'A'.
/// For 'A<P>*', getObjectType() will return 'A<P>'.
/// For 'AP*', getObjectType() will return 'A<P>'.
/// For 'A1*', getObjectType() will return 'A'.
/// For 'A1<P>*', getObjectType() will return 'A1<P>'.
/// For 'A1P*', getObjectType() will return 'A1<P>'.
/// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
///   adding protocols to a protocol-qualified base discards the
///   old qualifiers (for now).  But if it didn't, getObjectType()
///   would return 'A1P<Q>' (and we'd have to make iterating over
///   qualifiers more complicated).
const ObjCObjectType *getObjectType() const {
  return PointeeType->castAs<ObjCObjectType>();
}

/// If this pointer points to an Objective C
/// \@interface type, gets the type for that interface.  Any protocol
/// qualifiers on the interface are ignored.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
const ObjCInterfaceType *getInterfaceType() const;

/// If this pointer points to an Objective \@interface
/// type, gets the declaration for that interface.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
ObjCInterfaceDecl *getInterfaceDecl() const {
  return getObjectType()->getInterface();
}

/// True if this is equivalent to the 'id' type, i.e. if
/// its object type is the primitive 'id' type with no protocols.
bool isObjCIdType() const {
  return getObjectType()->isObjCUnqualifiedId();
}

/// True if this is equivalent to the 'Class' type,
/// i.e. if its object tive is the primitive 'Class' type with no protocols.
bool isObjCClassType() const {
  return getObjectType()->isObjCUnqualifiedClass();
}

/// True if this is equivalent to the 'id' or 'Class' type,
bool isObjCIdOrClassType() const {
  return getObjectType()->isObjCUnqualifiedIdOrClass();
}

/// True if this is equivalent to 'id<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedIdType() const {
  return getObjectType()->isObjCQualifiedId();
}

/// True if this is equivalent to 'Class<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedClassType() const {
  return getObjectType()->isObjCQualifiedClass();
}

/// Whether this is a "__kindof" type.
bool isKindOfType() const { return getObjectType()->isKindOfType(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecialized() const { return getObjectType()->isSpecialized(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecializedAsWritten() const {
  return getObjectType()->isSpecializedAsWritten();
}

/// Whether this type is unspecialized, meaning that is has no type arguments.
bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgs() const {
  return getObjectType()->getTypeArgs();
}

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return getObjectType()->getTypeArgsAsWritten();
}

/// An iterator over the qualifiers on the object type.  Provided
/// for convenience.  This will always iterate over the full set of
/// protocols on a type, not just those provided directly.
using qual_iterator = ObjCObjectType::qual_iterator;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }

qual_iterator qual_begin() const {
  return getObjectType()->qual_begin();
}

qual_iterator qual_end() const {
  return getObjectType()->qual_end();
}

bool qual_empty() const { return getObjectType()->qual_empty(); }

/// Return the number of qualifying protocols on the object type.
unsigned getNumProtocols() const {
  return getObjectType()->getNumProtocols();
}

/// Retrieve a qualifying protocol by index on the object type.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  return getObjectType()->getProtocol(I);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Retrieve the type of the superclass of this object pointer type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// pointer to a specialization of the superclass type. Produces a
/// null type if there is no superclass.
QualType getSuperClassType() const;

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
                               const ASTContext &ctx) const;

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObjectPointer;
}
6243};

6245class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}

6253public:
/// Gets the type contained by this atomic type, i.e.
/// the type returned by performing an atomic load of this atomic type.
QualType getValueType() const { return ValueType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getValueType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Atomic;
}
6272};

6274/// PipeType - OpenCL20.
6275class PipeType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;
bool isRead;

PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
    : Type(Pipe, CanonicalPtr, elemType->getDependence()),
      ElementType(elemType), isRead(isRead) {}

6285public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }

QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), isReadOnly());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
  ID.AddPointer(T.getAsOpaquePtr());
  ID.AddBoolean(isRead);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Pipe;
}

bool isReadOnly() const { return isRead; }
6306};

6308/// A fixed int type of a specified bitwidth.
6309class ExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
unsigned IsUnsigned : 1;
unsigned NumBits : 24;

6314protected:
ExtIntType(bool isUnsigned, unsigned NumBits);

6317public:
bool isUnsigned() const { return IsUnsigned; }
bool isSigned() const { return !IsUnsigned; }
unsigned getNumBits() const { return NumBits; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, isUnsigned(), getNumBits());
}

static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
                    unsigned NumBits) {
  ID.AddBoolean(IsUnsigned);
  ID.AddInteger(NumBits);
}

static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6336};

6338class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
const ASTContext &Context;
llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;

6343protected:
DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
                    Expr *NumBits);

6347public:
bool isUnsigned() const;
bool isSigned() const { return !isUnsigned(); }
Expr *getNumBitsExpr() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, isUnsigned(), getNumBitsExpr());
}
static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    bool IsUnsigned, Expr *NumBitsExpr);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentExtInt;
}
6364};

6366/// A qualifier set is used to build a set of qualifiers.
6367class QualifierCollector : public Qualifiers {
6368public:
QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}

/// Collect any qualifiers on the given type and return an
/// unqualified type.  The qualifiers are assumed to be consistent
/// with those already in the type.
const Type *strip(QualType type) {
  addFastQualifiers(type.getLocalFastQualifiers());
  if (!type.hasLocalNonFastQualifiers())
    return type.getTypePtrUnsafe();

  const ExtQuals *extQuals = type.getExtQualsUnsafe();
  addConsistentQualifiers(extQuals->getQualifiers());
  return extQuals->getBaseType();
}

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, QualType QT) const;

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, const Type* T) const;
6389};

6391/// A container of type source information.
6392///
6393/// A client can read the relevant info using TypeLoc wrappers, e.g:
6394/// @code
6395/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6396/// TL.getBeginLoc().print(OS, SrcMgr);
6397/// @endcode
6398class alignas(8) TypeSourceInfo {
// Contains a memory block after the class, used for type source information,
// allocated by ASTContext.
friend class ASTContext;

QualType Ty;

TypeSourceInfo(QualType ty) : Ty(ty) {}

6407public:
/// Return the type wrapped by this type source info.
QualType getType() const { return Ty; }

/// Return the TypeLoc wrapper for the type source info.
TypeLoc getTypeLoc() const; // implemented in TypeLoc.h

/// Override the type stored in this TypeSourceInfo. Use with caution!
void overrideType(QualType T) { Ty = T; }
6416};

6418// Inline function definitions.

6420inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6425}

6427inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6429}

6431inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6433}

6435inline SplitQualType QualType::split() const {
if (!hasLocalNonFastQualifiers())
  return SplitQualType(getTypePtrUnsafe(),
                       Qualifiers::fromFastMask(getLocalFastQualifiers()));

const ExtQuals *eq = getExtQualsUnsafe();
Qualifiers qs = eq->getQualifiers();
qs.addFastQualifiers(getLocalFastQualifiers());
return SplitQualType(eq->getBaseType(), qs);
6444}

6446inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6452}

6454inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6458}

6460inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6464}

6466inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6469}

6471inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6473}

6475inline bool QualType::isCanonicalAsParam() const {
if (!isCanonical()) return false;
if (hasLocalQualifiers()) return false;

const Type *T = getTypePtr();
if (T->isVariablyModifiedType() && T->hasSizedVLAType())
  return false;

return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6484}

6486inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6489}

6491inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6494}


6497inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6500}

6502inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6505}

6507inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6512}

6514inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6519}

6521inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6523}

6525inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6527}

6529inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6531}

6533inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((void)0);
static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
              "Fast bits differ from CVR bits!");

// Fast path: we don't need to touch the slow qualifiers.
removeLocalFastQualifiers(Mask);
6540}

6542/// Check if this type has any address space qualifier.
6543inline bool QualType::hasAddressSpace() const {
return getQualifiers().hasAddressSpace();
6545}

6547/// Return the address space of this type.
6548inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6550}

6552/// Return the gc attribute of this type.
6553inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6555}

6557inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6561}

6563inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6567}

6569inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6573}

6575inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const auto *PT = t.getAs<PointerType>()) {
  if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const auto *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
6583}

6585inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6587}

6589/// Determine whether this type is more
6590/// qualified than the Other type. For example, "const volatile int"
6591/// is more qualified than "const int", "volatile int", and
6592/// "int". However, it is not more qualified than "const volatile
6593/// int".
6594inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6598}

6600/// Determine whether this type is at last
6601/// as qualified as the Other type. For example, "const volatile
6602/// int" is at least as qualified as "const int", "volatile int",
6603/// "int", and "const volatile int".
6604inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
Qualifiers OtherQuals = other.getQualifiers();

// Ignore __unaligned qualifier if this type is a void.
if (getUnqualifiedType()->isVoidType())
  OtherQuals.removeUnaligned();

return getQualifiers().compatiblyIncludes(OtherQuals);
6612}

6614/// If Type is a reference type (e.g., const
6615/// int&), returns the type that the reference refers to ("const
6616/// int"). Otherwise, returns the type itself. This routine is used
6617/// throughout Sema to implement C++ 5p6:
6618///
6619///   If an expression initially has the type "reference to T" (8.3.2,
6620///   8.5.3), the type is adjusted to "T" prior to any further
6621///   analysis, the expression designates the object or function
6622///   denoted by the reference, and the expression is an lvalue.
6623inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6628}

6630inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6633}

6635/// Tests whether the type is categorized as a fundamental type.
6636///
6637/// \returns True for types specified in C++0x [basic.fundamental].
6638inline bool Type::isFundamentalType() const {
return isVoidType() ||
       isNullPtrType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
6644}

6646/// Tests whether the type is categorized as a compound type.
6647///
6648/// \returns True for types specified in C++0x [basic.compound].
6649inline bool Type::isCompoundType() const {
// C++0x [basic.compound]p1:
//   Compound types can be constructed in the following ways:
//    -- arrays of objects of a given type [...];
return isArrayType() ||
//    -- functions, which have parameters of given types [...];
       isFunctionType() ||
//    -- pointers to void or objects or functions [...];
       isPointerType() ||
//    -- references to objects or functions of a given type. [...]
       isReferenceType() ||
//    -- classes containing a sequence of objects of various types, [...];
       isRecordType() ||
//    -- unions, which are classes capable of containing objects of different
//               types at different times;
       isUnionType() ||
//    -- enumerations, which comprise a set of named constant values. [...];
       isEnumeralType() ||
//    -- pointers to non-static class members, [...].
       isMemberPointerType();
6669}

6671inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6673}

6675inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6677}

6679inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6681}

6683inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6685}

6687inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6689}

6691inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6693}

6695inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6697}

6699inline bool Type::isObjectPointerType() const {
// Note: an "object pointer type" is not the same thing as a pointer to an
// object type; rather, it is a pointer to an object type or a pointer to cv
// void.
if (const auto *T = getAs<PointerType>())
  return !T->getPointeeType()->isFunctionType();
else
  return false;
6707}

6709inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6714}

6716inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6721}

6723inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6725}

6727inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6732}

6734inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6739}

6741inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6743}

6745inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6747}

6749inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6751}

6753inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6755}

6757inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6759}

6761inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6763}

6765inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6767}

6769inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6771}

6773inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6775}

6777inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6779}

6781inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6783}

6785inline bool Type::isMatrixType() const {
return isa<MatrixType>(CanonicalType);
6787}

6789inline bool Type::isConstantMatrixType() const {
return isa<ConstantMatrixType>(CanonicalType);
6791}

6793inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6795}

6797inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6799}

6801inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6803}

6805inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6808}

6810inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6812}

6814inline bool Type::isUndeducedAutoType() const {
return isa<AutoType>(CanonicalType);
6816}

6818inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6822}

6824inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6828}

6830inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6834}

6836inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6840}

6842inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6846}

6848inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6850}

6852inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6854}

6856#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6860#include "clang/Basic/OpenCLImageTypes.def"

6862inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6864}

6866inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6868}

6870inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6872}

6874inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6876}

6878inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6880}

6882inline bool Type::isImageType() const {
6883#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6885#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6887}

6889inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6891}

6893inline bool Type::isExtIntType() const {
return isa<ExtIntType>(CanonicalType);
6895}

6897#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6901#include "clang/Basic/OpenCLExtensionTypes.def"

6903inline bool Type::isOCLIntelSubgroupAVCType() const {
6904#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6907#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6909}

6911inline bool Type::isOCLExtOpaqueType() const {
6912#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6914#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6916}

6918inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6921}

6923inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6925}

6927inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>()) {
  return BT->getKind() == static_cast<BuiltinType::Kind>(K);
}
return false;
6932}

6934inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6938}

6940inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6945}

6947inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((void)0);
return isSpecificBuiltinType(K);
6950}

6952inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6956}

6958inline bool Type::isVoidType() const {
return isSpecificBuiltinType(BuiltinType::Void);
6960}

6962inline bool Type::isHalfType() const {
// FIXME: Should we allow complex __fp16? Probably not.
return isSpecificBuiltinType(BuiltinType::Half);
6965}

6967inline bool Type::isFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::Float16);
6969}

6971inline bool Type::isBFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::BFloat16);
6973}

6975inline bool Type::isFloat128Type() const {
return isSpecificBuiltinType(BuiltinType::Float128);
6977}

6979inline bool Type::isNullPtrType() const {
return isSpecificBuiltinType(BuiltinType::NullPtr);
6981}

6983bool IsEnumDeclComplete(EnumDecl *);
6984bool IsEnumDeclScoped(EnumDecl *);

6986inline bool Type::isIntegerType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
  // Incomplete enum types are not treated as integer types.
  // FIXME: In C++, enum types are never integer types.
  return IsEnumDeclComplete(ET->getDecl()) &&
    !IsEnumDeclScoped(ET->getDecl());
}
return isExtIntType();
6997}

6999inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7005}

7007inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
7009}

7011inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7017}

7019inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
7021}

7023inline bool Type::isSignedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return ((BT->getKind() >= BuiltinType::ShortAccum &&
           BT->getKind() <= BuiltinType::LongAccum) ||
          (BT->getKind() >= BuiltinType::ShortFract &&
           BT->getKind() <= BuiltinType::LongFract) ||
          (BT->getKind() >= BuiltinType::SatShortAccum &&
           BT->getKind() <= BuiltinType::SatLongAccum) ||
          (BT->getKind() >= BuiltinType::SatShortFract &&
           BT->getKind() <= BuiltinType::SatLongFract));
}
return false;
7035}

7037inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
7039}

7041inline bool Type::isScalarType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() > BuiltinType::Void &&
         BT->getKind() <= BuiltinType::NullPtr;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  // Enums are scalar types, but only if they are defined.  Incomplete enums
  // are not treated as scalar types.
  return IsEnumDeclComplete(ET->getDecl());
return isa<PointerType>(CanonicalType) ||
       isa<BlockPointerType>(CanonicalType) ||
       isa<MemberPointerType>(CanonicalType) ||
       isa<ComplexType>(CanonicalType) ||
       isa<ObjCObjectPointerType>(CanonicalType) ||
       isExtIntType();
7055}

7057inline bool Type::isIntegralOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;

// Check for a complete enum type; incomplete enum types are not properly an
// enumeration type in the sense required here.
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return isExtIntType();
7068}

7070inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
7074}

7076inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
7079}

7081/// Determines whether this is a type for which one can define
7082/// an overloaded operator.
7083inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
7085}

7087/// Determines whether this type is written as a typedef-name.
7088inline bool Type::isTypedefNameType() const {
if (getAs<TypedefType>())
  return true;
if (auto *TST = getAs<TemplateSpecializationType>())
  return TST->isTypeAlias();
return false;
7094}

7096/// Determines whether this type can decay to a pointer type.
7097inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
7099}

7101inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
7104}

7106inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
7108}

7110inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
7115}

7117inline const Type *Type::getPointeeOrArrayElementType() const {
const Type *type = this;
if (type->isAnyPointerType())
  return type->getPointeeType().getTypePtr();
else if (type->isArrayType())
  return type->getBaseElementTypeUnsafe();
return type;
7124}
7125/// Insertion operator for partial diagnostics. This allows sending adress
7126/// spaces into a diagnostic with <<.
7127inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           LangAS AS) {
PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return PD;
7132}

7134/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7135/// into a diagnostic with <<.
7136inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
7141}

7143/// Insertion operator for partial diagnostics.  This allows sending QualType's
7144/// into a diagnostic with <<.
7145inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
7150}

7152// Helper class template that is used by Type::getAs to ensure that one does
7153// not try to look through a qualified type to get to an array type.
7154template <typename T>
7155using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

7159// Member-template getAs<specific type>'.
7160template <typename T> const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with getAs!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
7175}

7177template <typename T> const T *Type::getAsAdjusted() const {
static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// Strip off type adjustments that do not modify the underlying nature of the
// type.
const Type *Ty = this;
while (Ty) {
  if (const auto *A = dyn_cast<AttributedType>(Ty))
    Ty = A->getModifiedType().getTypePtr();
  else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
    Ty = E->desugar().getTypePtr();
  else if (const auto *P = dyn_cast<ParenType>(Ty))
    Ty = P->desugar().getTypePtr();
  else if (const auto *A = dyn_cast<AdjustedType>(Ty))
    Ty = A->desugar().getTypePtr();
  else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
    Ty = M->desugar().getTypePtr();
  else
    break;
}

// Just because the canonical type is correct does not mean we can use cast<>,
// since we may not have stripped off all the sugar down to the base type.
return dyn_cast<T>(Ty);
7209}

7211inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const auto *arr = dyn_cast<ArrayType>(this))
  return arr;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<ArrayType>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType());
7223}

7225template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const auto *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))((void)0);
return cast<T>(getUnqualifiedDesugaredType());
7232}

7234inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((void)0);
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
7238}

7240DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7243#ifndef NDEBUG1
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((void)0);
7247#endif
7248}

7250QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
7254}

7256// Get the decimal string representation of a fixed point type, represented
7257// as a scaled integer.
7258// TODO: At some point, we should change the arguments to instead just accept an
7259// APFixedPoint instead of APSInt and scale.
7260void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

7263} // namespace clang

7265#endif // LLVM_CLANG_AST_TYPE_H

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include/llvm/ADT/PointerUnion.h

→

1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- 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// This file defines the PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16 
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23 
24namespace llvm {
25 
26template <typename T> struct PointerUnionTypeSelectorReturn {
27  using Return = T;
28};
29 
30/// Get a type based on whether two types are the same or not.
31///
32/// For:
33///
34/// \code
35///   using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
36/// \endcode
37///
38/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
39template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
40struct PointerUnionTypeSelector {
41  using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
42};
43 
44template <typename T, typename RET_EQ, typename RET_NE>
45struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
46  using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
47};
48 
49template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
50struct PointerUnionTypeSelectorReturn<
51    PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
52  using Return =
53      typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
54};
55 
56namespace pointer_union_detail {
57  /// Determine the number of bits required to store integers with values < n.
58  /// This is ceil(log2(n)).
59  constexpr int bitsRequired(unsigned n) {
60    return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
61  }
62 
63  template <typename... Ts> constexpr int lowBitsAvailable() {
64    return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
65  }
66 
67  /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
68  /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
69  /// list.
70  template <typename T, typename ...Us> struct TypeIndex;
71  template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
72    static constexpr int Index = 0;
73  };
74  template <typename T, typename U, typename... Us>
75  struct TypeIndex<T, U, Us...> {
76    static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
77  };
78  template <typename T> struct TypeIndex<T> {
79    static constexpr int Index = 0;
80  };
81 
82  /// Find the first type in a list of types.
83  template <typename T, typename...> struct GetFirstType {
84    using type = T;
85  };
86 
87  /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
88  /// for the template arguments.
89  template <typename ...PTs> class PointerUnionUIntTraits {
90  public:
91    static inline void *getAsVoidPointer(void *P) { return P; }
92    static inline void *getFromVoidPointer(void *P) { return P; }
17
←
Returning null pointer (loaded from 'P'), which participates in a condition later→
93    static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
94  };
95 
96  template <typename Derived, typename ValTy, int I, typename ...Types>
97  class PointerUnionMembers;
98 
99  template <typename Derived, typename ValTy, int I>
100  class PointerUnionMembers<Derived, ValTy, I> {
101  protected:
102    ValTy Val;
103    PointerUnionMembers() = default;
104    PointerUnionMembers(ValTy Val) : Val(Val) {}
105 
106    friend struct PointerLikeTypeTraits<Derived>;
107  };
108 
109  template <typename Derived, typename ValTy, int I, typename Type,
110            typename ...Types>
111  class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
112      : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
113    using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
114  public:
115    using Base::Base;
116    PointerUnionMembers() = default;
117    PointerUnionMembers(Type V)
118        : Base(ValTy(const_cast<void *>(
119                         PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
120                     I)) {}
121 
122    using Base::operator=;
123    Derived &operator=(Type V) {
124      this->Val = ValTy(
125          const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
126          I);
127      return static_cast<Derived &>(*this);
128    };
129  };
130}
131 
132/// A discriminated union of two or more pointer types, with the discriminator
133/// in the low bit of the pointer.
134///
135/// This implementation is extremely efficient in space due to leveraging the
136/// low bits of the pointer, while exposing a natural and type-safe API.
137///
138/// Common use patterns would be something like this:
139///    PointerUnion<int*, float*> P;
140///    P = (int*)0;
141///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
142///    X = P.get<int*>();     // ok.
143///    Y = P.get<float*>();   // runtime assertion failure.
144///    Z = P.get<double*>();  // compile time failure.
145///    P = (float*)0;
146///    Y = P.get<float*>();   // ok.
147///    X = P.get<int*>();     // runtime assertion failure.
148template <typename... PTs>
149class PointerUnion
150    : public pointer_union_detail::PointerUnionMembers<
151          PointerUnion<PTs...>,
152          PointerIntPair<
153              void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
154              pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
155          0, PTs...> {
156  // The first type is special because we want to directly cast a pointer to a
157  // default-initialized union to a pointer to the first type. But we don't
158  // want PointerUnion to be a 'template <typename First, typename ...Rest>'
159  // because it's much more convenient to have a name for the whole pack. So
160  // split off the first type here.
161  using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
162  using Base = typename PointerUnion::PointerUnionMembers;
163 
164public:
165  PointerUnion() = default;
166 
167  PointerUnion(std::nullptr_t) : PointerUnion() {}
168  using Base::Base;
169 
170  /// Test if the pointer held in the union is null, regardless of
171  /// which type it is.
172  bool isNull() const { return !this->Val.getPointer(); }
14
←
Calling 'PointerIntPair::getPointer'→
22
←
Returning from 'PointerIntPair::getPointer'→
23
←
Returning the value 1, which participates in a condition later→
173 
174  explicit operator bool() const { return !isNull(); }
175 
176  /// Test if the Union currently holds the type matching T.
177  template <typename T> bool is() const {
178    constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
179    static_assert(Index < sizeof...(PTs),
180                  "PointerUnion::is<T> given type not in the union");
181    return this->Val.getInt() == Index;
182  }
183 
184  /// Returns the value of the specified pointer type.
185  ///
186  /// If the specified pointer type is incorrect, assert.
187  template <typename T> T get() const {
188    assert(is<T>() && "Invalid accessor called")((void)0);
189    return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
190  }
191 
192  /// Returns the current pointer if it is of the specified pointer type,
193  /// otherwise returns null.
194  template <typename T> T dyn_cast() const {
195    if (is<T>())
196      return get<T>();
197    return T();
198  }
199 
200  /// If the union is set to the first pointer type get an address pointing to
201  /// it.
202  First const *getAddrOfPtr1() const {
203    return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
204  }
205 
206  /// If the union is set to the first pointer type get an address pointing to
207  /// it.
208  First *getAddrOfPtr1() {
209    assert(is<First>() && "Val is not the first pointer")((void)0);
210    assert(((void)0)
211        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((void)0)
212            this->Val.getPointer() &&((void)0)
213        "Can't get the address because PointerLikeTypeTraits changes the ptr")((void)0);
214    return const_cast<First *>(
215        reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
216  }
217 
218  /// Assignment from nullptr which just clears the union.
219  const PointerUnion &operator=(std::nullptr_t) {
220    this->Val.initWithPointer(nullptr);
221    return *this;
222  }
223 
224  /// Assignment from elements of the union.
225  using Base::operator=;
226 
227  void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
228  static inline PointerUnion getFromOpaqueValue(void *VP) {
229    PointerUnion V;
230    V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
231    return V;
232  }
233};
234 
235template <typename ...PTs>
236bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
237  return lhs.getOpaqueValue() == rhs.getOpaqueValue();
238}
239 
240template <typename ...PTs>
241bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
242  return lhs.getOpaqueValue() != rhs.getOpaqueValue();
243}
244 
245template <typename ...PTs>
246bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
247  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
248}
249 
250// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
251// # low bits available = min(PT1bits,PT2bits)-1.
252template <typename ...PTs>
253struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
254  static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
255    return P.getOpaqueValue();
256  }
257 
258  static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
259    return PointerUnion<PTs...>::getFromOpaqueValue(P);
260  }
261 
262  // The number of bits available are the min of the pointer types minus the
263  // bits needed for the discriminator.
264  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
265      PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
266};
267 
268// Teach DenseMap how to use PointerUnions as keys.
269template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
270  using Union = PointerUnion<PTs...>;
271  using FirstInfo =
272      DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
273 
274  static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
275 
276  static inline Union getTombstoneKey() {
277    return Union(FirstInfo::getTombstoneKey());
278  }
279 
280  static unsigned getHashValue(const Union &UnionVal) {
281    intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
282    return DenseMapInfo<intptr_t>::getHashValue(key);
283  }
284 
285  static bool isEqual(const Union &LHS, const Union &RHS) {
286    return LHS == RHS;
287  }
288};
289 
290} // end namespace llvm
291 
292#endif // LLVM_ADT_POINTERUNION_H

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include/llvm/ADT/PointerIntPair.h

1//===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- 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// This file defines the PointerIntPair class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_ADT_POINTERINTPAIR_H
14#define LLVM_ADT_POINTERINTPAIR_H

16#include "llvm/Support/Compiler.h"
17#include "llvm/Support/PointerLikeTypeTraits.h"
18#include "llvm/Support/type_traits.h"
19#include <cassert>
20#include <cstdint>
21#include <limits>

23namespace llvm {

25template <typename T> struct DenseMapInfo;
26template <typename PointerT, unsigned IntBits, typename PtrTraits>
27struct PointerIntPairInfo;

29/// PointerIntPair - This class implements a pair of a pointer and small
30/// integer.  It is designed to represent this in the space required by one
31/// pointer by bitmangling the integer into the low part of the pointer.  This
32/// can only be done for small integers: typically up to 3 bits, but it depends
33/// on the number of bits available according to PointerLikeTypeTraits for the
34/// type.
35///
36/// Note that PointerIntPair always puts the IntVal part in the highest bits
37/// possible.  For example, PointerIntPair<void*, 1, bool> will put the bit for
38/// the bool into bit #2, not bit #0, which allows the low two bits to be used
39/// for something else.  For example, this allows:
40///   PointerIntPair<PointerIntPair<void*, 1, bool>, 1, bool>
41/// ... and the two bools will land in different bits.
42template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
        typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
        typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
45class PointerIntPair {
// Used by MSVC visualizer and generally helpful for debugging/visualizing.
using InfoTy = Info;
intptr_t Value = 0;

50public:
constexpr PointerIntPair() = default;

PointerIntPair(PointerTy PtrVal, IntType IntVal) {
  setPointerAndInt(PtrVal, IntVal);
}

explicit PointerIntPair(PointerTy PtrVal) { initWithPointer(PtrVal); }

PointerTy getPointer() const { return Info::getPointer(Value); }
15
←
Calling 'PointerIntPairInfo::getPointer'→
20
←
Returning from 'PointerIntPairInfo::getPointer'→
21
←
Returning null pointer, which participates in a condition later→

IntType getInt() const { return (IntType)Info::getInt(Value); }

void setPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION& {
  Value = Info::updatePointer(Value, PtrVal);
}

void setInt(IntType IntVal) LLVM_LVALUE_FUNCTION& {
  Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));
}

void initWithPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION& {
  Value = Info::updatePointer(0, PtrVal);
}

void setPointerAndInt(PointerTy PtrVal, IntType IntVal) LLVM_LVALUE_FUNCTION& {
  Value = Info::updateInt(Info::updatePointer(0, PtrVal),
                          static_cast<intptr_t>(IntVal));
}

PointerTy const *getAddrOfPointer() const {
  return const_cast<PointerIntPair *>(this)->getAddrOfPointer();
}

PointerTy *getAddrOfPointer() {
  assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&((void)0)
         "Can only return the address if IntBits is cleared and "((void)0)
         "PtrTraits doesn't change the pointer")((void)0);
  return reinterpret_cast<PointerTy *>(&Value);
}

void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }

void setFromOpaqueValue(void *Val) LLVM_LVALUE_FUNCTION& {
  Value = reinterpret_cast<intptr_t>(Val);
}

static PointerIntPair getFromOpaqueValue(void *V) {
  PointerIntPair P;
  P.setFromOpaqueValue(V);
  return P;
}

// Allow PointerIntPairs to be created from const void * if and only if the
// pointer type could be created from a const void *.
static PointerIntPair getFromOpaqueValue(const void *V) {
  (void)PtrTraits::getFromVoidPointer(V);
  return getFromOpaqueValue(const_cast<void *>(V));
}

bool operator==(const PointerIntPair &RHS) const {
  return Value == RHS.Value;
}

bool operator!=(const PointerIntPair &RHS) const {
  return Value != RHS.Value;
}

bool operator<(const PointerIntPair &RHS) const { return Value < RHS.Value; }
bool operator>(const PointerIntPair &RHS) const { return Value > RHS.Value; }

bool operator<=(const PointerIntPair &RHS) const {
  return Value <= RHS.Value;
}

bool operator>=(const PointerIntPair &RHS) const {
  return Value >= RHS.Value;
}
128};

130// Specialize is_trivially_copyable to avoid limitation of llvm::is_trivially_copyable
131// when compiled with gcc 4.9.
132template <typename PointerTy, unsigned IntBits, typename IntType,
        typename PtrTraits,
        typename Info>
135struct is_trivially_copyable<PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>> : std::true_type {
136#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE
static_assert(std::is_trivially_copyable<PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>::value,
              "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable");
139#endif
140};


143template <typename PointerT, unsigned IntBits, typename PtrTraits>
144struct PointerIntPairInfo {
static_assert(PtrTraits::NumLowBitsAvailable <
                  std::numeric_limits<uintptr_t>::digits,
              "cannot use a pointer type that has all bits free");
static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,
              "PointerIntPair with integer size too large for pointer");
enum MaskAndShiftConstants : uintptr_t {
  /// PointerBitMask - The bits that come from the pointer.
  PointerBitMask =
      ~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),

  /// IntShift - The number of low bits that we reserve for other uses, and
  /// keep zero.
  IntShift = (uintptr_t)PtrTraits::NumLowBitsAvailable - IntBits,

  /// IntMask - This is the unshifted mask for valid bits of the int type.
  IntMask = (uintptr_t)(((intptr_t)1 << IntBits) - 1),

  // ShiftedIntMask - This is the bits for the integer shifted in place.
  ShiftedIntMask = (uintptr_t)(IntMask << IntShift)
};

static PointerT getPointer(intptr_t Value) {
  return PtrTraits::getFromVoidPointer(
16
←
Calling 'PointerUnionUIntTraits::getFromVoidPointer'→
18
←
Returning from 'PointerUnionUIntTraits::getFromVoidPointer'→
19
←
Returning null pointer, which participates in a condition later→
      reinterpret_cast<void *>(Value & PointerBitMask));
}

static intptr_t getInt(intptr_t Value) {
  return (Value >> IntShift) & IntMask;
}

static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {
  intptr_t PtrWord =
      reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));
  assert((PtrWord & ~PointerBitMask) == 0 &&((void)0)
         "Pointer is not sufficiently aligned")((void)0);
  // Preserve all low bits, just update the pointer.
  return PtrWord | (OrigValue & ~PointerBitMask);
}

static intptr_t updateInt(intptr_t OrigValue, intptr_t Int) {
  intptr_t IntWord = static_cast<intptr_t>(Int);
  assert((IntWord & ~IntMask) == 0 && "Integer too large for field")((void)0);

  // Preserve all bits other than the ones we are updating.
  return (OrigValue & ~ShiftedIntMask) | IntWord << IntShift;
}
191};

193// Provide specialization of DenseMapInfo for PointerIntPair.
194template <typename PointerTy, unsigned IntBits, typename IntType>
195struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
using Ty = PointerIntPair<PointerTy, IntBits, IntType>;

static Ty getEmptyKey() {
  uintptr_t Val = static_cast<uintptr_t>(-1);
  Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;
  return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
}

static Ty getTombstoneKey() {
  uintptr_t Val = static_cast<uintptr_t>(-2);
  Val <<= PointerLikeTypeTraits<PointerTy>::NumLowBitsAvailable;
  return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
}

static unsigned getHashValue(Ty V) {
  uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());
  return unsigned(IV) ^ unsigned(IV >> 9);
}

static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }
216};

218// Teach SmallPtrSet that PointerIntPair is "basically a pointer".
219template <typename PointerTy, unsigned IntBits, typename IntType,
        typename PtrTraits>
221struct PointerLikeTypeTraits<
  PointerIntPair<PointerTy, IntBits, IntType, PtrTraits>> {
static inline void *
getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
  return P.getOpaqueValue();
}

static inline PointerIntPair<PointerTy, IntBits, IntType>
getFromVoidPointer(void *P) {
  return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
}

static inline PointerIntPair<PointerTy, IntBits, IntType>
getFromVoidPointer(const void *P) {
  return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
}

static constexpr int NumLowBitsAvailable =
    PtrTraits::NumLowBitsAvailable - IntBits;
240};

242} // end namespace llvm

244#endif // LLVM_ADT_POINTERINTPAIR_H