/build/source/clang/lib/Sema/TreeTransform.h

Bug Summary

File:	build/source/clang/lib/Sema/TreeTransform.h
Warning:	line 6367, column 21 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateInstantiateDecl.cpp -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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-17/lib/clang/17 -I tools/clang/lib/Sema -I /build/source/clang/lib/Sema -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

/build/source/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

→

1//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
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 C++ template instantiation for declarations.
9//
10//===----------------------------------------------------------------------===/

12#include "TreeTransform.h"
13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/DeclVisitor.h"
18#include "clang/AST/DependentDiagnostic.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprCXX.h"
21#include "clang/AST/PrettyDeclStackTrace.h"
22#include "clang/AST/TypeLoc.h"
23#include "clang/Basic/SourceManager.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Sema/EnterExpressionEvaluationContext.h"
26#include "clang/Sema/Initialization.h"
27#include "clang/Sema/Lookup.h"
28#include "clang/Sema/ScopeInfo.h"
29#include "clang/Sema/SemaInternal.h"
30#include "clang/Sema/Template.h"
31#include "clang/Sema/TemplateInstCallback.h"
32#include "llvm/Support/TimeProfiler.h"
33#include <optional>

35using namespace clang;

37static bool isDeclWithinFunction(const Decl *D) {
const DeclContext *DC = D->getDeclContext();
if (DC->isFunctionOrMethod())
  return true;

if (DC->isRecord())
  return cast<CXXRecordDecl>(DC)->isLocalClass();

return false;
46}

48template<typename DeclT>
49static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
                         const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!OldDecl->getQualifierLoc())
  return false;

assert((NewDecl->getFriendObjectKind() ||(static_cast <bool> ((NewDecl->getFriendObjectKind()
 || !OldDecl->getLexicalDeclContext()->isDependentContext
()) && "non-friend with qualified name defined in dependent context"
) ? void (0) : __assert_fail ("(NewDecl->getFriendObjectKind() || !OldDecl->getLexicalDeclContext()->isDependentContext()) && \"non-friend with qualified name defined in dependent context\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 56, __extension__
 __PRETTY_FUNCTION__))
        !OldDecl->getLexicalDeclContext()->isDependentContext()) &&(static_cast <bool> ((NewDecl->getFriendObjectKind()
 || !OldDecl->getLexicalDeclContext()->isDependentContext
()) && "non-friend with qualified name defined in dependent context"
) ? void (0) : __assert_fail ("(NewDecl->getFriendObjectKind() || !OldDecl->getLexicalDeclContext()->isDependentContext()) && \"non-friend with qualified name defined in dependent context\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 56, __extension__
 __PRETTY_FUNCTION__))
       "non-friend with qualified name defined in dependent context")(static_cast <bool> ((NewDecl->getFriendObjectKind()
 || !OldDecl->getLexicalDeclContext()->isDependentContext
()) && "non-friend with qualified name defined in dependent context"
) ? void (0) : __assert_fail ("(NewDecl->getFriendObjectKind() || !OldDecl->getLexicalDeclContext()->isDependentContext()) && \"non-friend with qualified name defined in dependent context\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 56, __extension__
 __PRETTY_FUNCTION__));
Sema::ContextRAII SavedContext(
    SemaRef,
    const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
                                  ? NewDecl->getLexicalDeclContext()
                                  : OldDecl->getLexicalDeclContext()));

NestedNameSpecifierLoc NewQualifierLoc
    = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
                                          TemplateArgs);

if (!NewQualifierLoc)
  return true;

NewDecl->setQualifierInfo(NewQualifierLoc);
return false;
72}

74bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
                                            DeclaratorDecl *NewDecl) {
return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
77}

79bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
                                            TagDecl *NewDecl) {
return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
82}

84// Include attribute instantiation code.
85#include "clang/Sema/AttrTemplateInstantiate.inc"

87static void instantiateDependentAlignedAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
if (Aligned->isAlignmentExpr()) {
  // The alignment expression is a constant expression.
  EnterExpressionEvaluationContext Unevaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
  if (!Result.isInvalid())
    S.AddAlignedAttr(New, *Aligned, Result.getAs<Expr>(), IsPackExpansion);
} else {
  TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
                                       TemplateArgs, Aligned->getLocation(),
                                       DeclarationName());
  if (Result)
    S.AddAlignedAttr(New, *Aligned, Result, IsPackExpansion);
}
104}

106static void instantiateDependentAlignedAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AlignedAttr *Aligned, Decl *New) {
if (!Aligned->isPackExpansion()) {
  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
  return;
}

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
if (Aligned->isAlignmentExpr())
  S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
                                    Unexpanded);
else
  S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
                                    Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 121, __extension__
 __PRETTY_FUNCTION__));

// Determine whether we can expand this attribute pack yet.
bool Expand = true, RetainExpansion = false;
std::optional<unsigned> NumExpansions;
// FIXME: Use the actual location of the ellipsis.
SourceLocation EllipsisLoc = Aligned->getLocation();
if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
                                      Unexpanded, TemplateArgs, Expand,
                                      RetainExpansion, NumExpansions))
  return;

if (!Expand) {
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
} else {
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
    instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
  }
}
142}

144static void instantiateDependentAssumeAlignedAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AssumeAlignedAttr *Aligned, Decl *New) {
// The alignment expression is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

Expr *E, *OE = nullptr;
ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
if (Result.isInvalid())
  return;
E = Result.getAs<Expr>();

if (Aligned->getOffset()) {
  Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
  if (Result.isInvalid())
    return;
  OE = Result.getAs<Expr>();
}

S.AddAssumeAlignedAttr(New, *Aligned, E, OE);
165}

167static void instantiateDependentAlignValueAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AlignValueAttr *Aligned, Decl *New) {
// The alignment expression is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
if (!Result.isInvalid())
  S.AddAlignValueAttr(New, *Aligned, Result.getAs<Expr>());
176}

178static void instantiateDependentAllocAlignAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AllocAlignAttr *Align, Decl *New) {
Expr *Param = IntegerLiteral::Create(
    S.getASTContext(),
    llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
    S.getASTContext().UnsignedLongLongTy, Align->getLocation());
S.AddAllocAlignAttr(New, *Align, Param);
186}

188static void instantiateDependentAnnotationAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AnnotateAttr *Attr, Decl *New) {
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

// If the attribute has delayed arguments it will have to instantiate those
// and handle them as new arguments for the attribute.
bool HasDelayedArgs = Attr->delayedArgs_size();

ArrayRef<Expr *> ArgsToInstantiate =
    HasDelayedArgs
        ? ArrayRef<Expr *>{Attr->delayedArgs_begin(), Attr->delayedArgs_end()}
        : ArrayRef<Expr *>{Attr->args_begin(), Attr->args_end()};

SmallVector<Expr *, 4> Args;
if (S.SubstExprs(ArgsToInstantiate,
                 /*IsCall=*/false, TemplateArgs, Args))
  return;

StringRef Str = Attr->getAnnotation();
if (HasDelayedArgs) {
  if (Args.size() < 1) {
    S.Diag(Attr->getLoc(), diag::err_attribute_too_few_arguments)
        << Attr << 1;
    return;
  }

  if (!S.checkStringLiteralArgumentAttr(*Attr, Args[0], Str))
    return;

  llvm::SmallVector<Expr *, 4> ActualArgs;
  ActualArgs.insert(ActualArgs.begin(), Args.begin() + 1, Args.end());
  std::swap(Args, ActualArgs);
}
S.AddAnnotationAttr(New, *Attr, Str, Args);
224}

226static Expr *instantiateDependentFunctionAttrCondition(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
Expr *Cond = nullptr;
{
  Sema::ContextRAII SwitchContext(S, New);
  EnterExpressionEvaluationContext Unevaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
  if (Result.isInvalid())
    return nullptr;
  Cond = Result.getAs<Expr>();
}
if (!Cond->isTypeDependent()) {
  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
  if (Converted.isInvalid())
    return nullptr;
  Cond = Converted.get();
}

SmallVector<PartialDiagnosticAt, 8> Diags;
if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
    !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
  S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
  for (const auto &P : Diags)
    S.Diag(P.first, P.second);
  return nullptr;
}
return Cond;
255}

257static void instantiateDependentEnableIfAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
Expr *Cond = instantiateDependentFunctionAttrCondition(
    S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);

if (Cond)
  New->addAttr(new (S.getASTContext()) EnableIfAttr(S.getASTContext(), *EIA,
                                                    Cond, EIA->getMessage()));
266}

268static void instantiateDependentDiagnoseIfAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
Expr *Cond = instantiateDependentFunctionAttrCondition(
    S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);

if (Cond)
  New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
      S.getASTContext(), *DIA, Cond, DIA->getMessage(),
      DIA->getDiagnosticType(), DIA->getArgDependent(), New));
278}

280// Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
281// template A as the base and arguments from TemplateArgs.
282static void instantiateDependentCUDALaunchBoundsAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const CUDALaunchBoundsAttr &Attr, Decl *New) {
// The alignment expression is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
if (Result.isInvalid())
  return;
Expr *MaxThreads = Result.getAs<Expr>();

Expr *MinBlocks = nullptr;
if (Attr.getMinBlocks()) {
  Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
  if (Result.isInvalid())
    return;
  MinBlocks = Result.getAs<Expr>();
}

S.AddLaunchBoundsAttr(New, Attr, MaxThreads, MinBlocks);
303}

305static void
306instantiateDependentModeAttr(Sema &S,
                           const MultiLevelTemplateArgumentList &TemplateArgs,
                           const ModeAttr &Attr, Decl *New) {
S.AddModeAttr(New, Attr, Attr.getMode(),
              /*InInstantiation=*/true);
311}

313/// Instantiation of 'declare simd' attribute and its arguments.
314static void instantiateOMPDeclareSimdDeclAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
// Allow 'this' in clauses with varlists.
if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
  New = FTD->getTemplatedDecl();
auto *FD = cast<FunctionDecl>(New);
auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
SmallVector<unsigned, 4> LinModifiers;

auto SubstExpr = [&](Expr *E) -> ExprResult {
  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
      Sema::ContextRAII SavedContext(S, FD);
      LocalInstantiationScope Local(S);
      if (FD->getNumParams() > PVD->getFunctionScopeIndex())
        Local.InstantiatedLocal(
            PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
      return S.SubstExpr(E, TemplateArgs);
    }
  Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
                                   FD->isCXXInstanceMember());
  return S.SubstExpr(E, TemplateArgs);
};

// Substitute a single OpenMP clause, which is a potentially-evaluated
// full-expression.
auto Subst = [&](Expr *E) -> ExprResult {
  EnterExpressionEvaluationContext Evaluated(
      S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
  ExprResult Res = SubstExpr(E);
  if (Res.isInvalid())
    return Res;
  return S.ActOnFinishFullExpr(Res.get(), false);
};

ExprResult Simdlen;
if (auto *E = Attr.getSimdlen())
  Simdlen = Subst(E);

if (Attr.uniforms_size() > 0) {
  for(auto *E : Attr.uniforms()) {
    ExprResult Inst = Subst(E);
    if (Inst.isInvalid())
      continue;
    Uniforms.push_back(Inst.get());
  }
}

auto AI = Attr.alignments_begin();
for (auto *E : Attr.aligneds()) {
  ExprResult Inst = Subst(E);
  if (Inst.isInvalid())
    continue;
  Aligneds.push_back(Inst.get());
  Inst = ExprEmpty();
  if (*AI)
    Inst = S.SubstExpr(*AI, TemplateArgs);
  Alignments.push_back(Inst.get());
  ++AI;
}

auto SI = Attr.steps_begin();
for (auto *E : Attr.linears()) {
  ExprResult Inst = Subst(E);
  if (Inst.isInvalid())
    continue;
  Linears.push_back(Inst.get());
  Inst = ExprEmpty();
  if (*SI)
    Inst = S.SubstExpr(*SI, TemplateArgs);
  Steps.push_back(Inst.get());
  ++SI;
}
LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
(void)S.ActOnOpenMPDeclareSimdDirective(
    S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
    Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
    Attr.getRange());
394}

396/// Instantiation of 'declare variant' attribute and its arguments.
397static void instantiateOMPDeclareVariantAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const OMPDeclareVariantAttr &Attr, Decl *New) {
// Allow 'this' in clauses with varlists.
if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
  New = FTD->getTemplatedDecl();
auto *FD = cast<FunctionDecl>(New);
auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());

auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](Expr *E) {
  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
      Sema::ContextRAII SavedContext(S, FD);
      LocalInstantiationScope Local(S);
      if (FD->getNumParams() > PVD->getFunctionScopeIndex())
        Local.InstantiatedLocal(
            PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
      return S.SubstExpr(E, TemplateArgs);
    }
  Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
                                   FD->isCXXInstanceMember());
  return S.SubstExpr(E, TemplateArgs);
};

// Substitute a single OpenMP clause, which is a potentially-evaluated
// full-expression.
auto &&Subst = [&SubstExpr, &S](Expr *E) {
  EnterExpressionEvaluationContext Evaluated(
      S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
  ExprResult Res = SubstExpr(E);
  if (Res.isInvalid())
    return Res;
  return S.ActOnFinishFullExpr(Res.get(), false);
};

ExprResult VariantFuncRef;
if (Expr *E = Attr.getVariantFuncRef()) {
  // Do not mark function as is used to prevent its emission if this is the
  // only place where it is used.
  EnterExpressionEvaluationContext Unevaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  VariantFuncRef = Subst(E);
}

// Copy the template version of the OMPTraitInfo and run substitute on all
// score and condition expressiosn.
OMPTraitInfo &TI = S.getASTContext().getNewOMPTraitInfo();
TI = *Attr.getTraitInfos();

// Try to substitute template parameters in score and condition expressions.
auto SubstScoreOrConditionExpr = [&S, Subst](Expr *&E, bool) {
  if (E) {
    EnterExpressionEvaluationContext Unevaluated(
        S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
    ExprResult ER = Subst(E);
    if (ER.isUsable())
      E = ER.get();
    else
      return true;
  }
  return false;
};
if (TI.anyScoreOrCondition(SubstScoreOrConditionExpr))
  return;

Expr *E = VariantFuncRef.get();

// Check function/variant ref for `omp declare variant` but not for `omp
// begin declare variant` (which use implicit attributes).
std::optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
    S.checkOpenMPDeclareVariantFunction(S.ConvertDeclToDeclGroup(New), E, TI,
                                        Attr.appendArgs_size(),
                                        Attr.getRange());

if (!DeclVarData)
  return;

E = DeclVarData->second;
FD = DeclVarData->first;

if (auto *VariantDRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
  if (auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
    if (auto *VariantFTD = VariantFD->getDescribedFunctionTemplate()) {
      if (!VariantFTD->isThisDeclarationADefinition())
        return;
      Sema::TentativeAnalysisScope Trap(S);
      const TemplateArgumentList *TAL = TemplateArgumentList::CreateCopy(
          S.Context, TemplateArgs.getInnermost());

      auto *SubstFD = S.InstantiateFunctionDeclaration(VariantFTD, TAL,
                                                       New->getLocation());
      if (!SubstFD)
        return;
      QualType NewType = S.Context.mergeFunctionTypes(
          SubstFD->getType(), FD->getType(),
          /* OfBlockPointer */ false,
          /* Unqualified */ false, /* AllowCXX */ true);
      if (NewType.isNull())
        return;
      S.InstantiateFunctionDefinition(
          New->getLocation(), SubstFD, /* Recursive */ true,
          /* DefinitionRequired */ false, /* AtEndOfTU */ false);
      SubstFD->setInstantiationIsPending(!SubstFD->isDefined());
      E = DeclRefExpr::Create(S.Context, NestedNameSpecifierLoc(),
                              SourceLocation(), SubstFD,
                              /* RefersToEnclosingVariableOrCapture */ false,
                              /* NameLoc */ SubstFD->getLocation(),
                              SubstFD->getType(), ExprValueKind::VK_PRValue);
    }
  }
}

SmallVector<Expr *, 8> NothingExprs;
SmallVector<Expr *, 8> NeedDevicePtrExprs;
SmallVector<OMPInteropInfo, 4> AppendArgs;

for (Expr *E : Attr.adjustArgsNothing()) {
  ExprResult ER = Subst(E);
  if (ER.isInvalid())
    continue;
  NothingExprs.push_back(ER.get());
}
for (Expr *E : Attr.adjustArgsNeedDevicePtr()) {
  ExprResult ER = Subst(E);
  if (ER.isInvalid())
    continue;
  NeedDevicePtrExprs.push_back(ER.get());
}
for (OMPInteropInfo &II : Attr.appendArgs()) {
  // When prefer_type is implemented for append_args handle them here too.
  AppendArgs.emplace_back(II.IsTarget, II.IsTargetSync);
}

S.ActOnOpenMPDeclareVariantDirective(
    FD, E, TI, NothingExprs, NeedDevicePtrExprs, AppendArgs, SourceLocation(),
    SourceLocation(), Attr.getRange());
533}

535static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New) {
// Both min and max expression are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
if (Result.isInvalid())
  return;
Expr *MinExpr = Result.getAs<Expr>();

Result = S.SubstExpr(Attr.getMax(), TemplateArgs);
if (Result.isInvalid())
  return;
Expr *MaxExpr = Result.getAs<Expr>();

S.addAMDGPUFlatWorkGroupSizeAttr(New, Attr, MinExpr, MaxExpr);
553}

555static ExplicitSpecifier
556instantiateExplicitSpecifier(Sema &S,
                           const MultiLevelTemplateArgumentList &TemplateArgs,
                           ExplicitSpecifier ES, FunctionDecl *New) {
if (!ES.getExpr())
  return ES;
Expr *OldCond = ES.getExpr();
Expr *Cond = nullptr;
{
  EnterExpressionEvaluationContext Unevaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult SubstResult = S.SubstExpr(OldCond, TemplateArgs);
  if (SubstResult.isInvalid()) {
    return ExplicitSpecifier::Invalid();
  }
  Cond = SubstResult.get();
}
ExplicitSpecifier Result(Cond, ES.getKind());
if (!Cond->isTypeDependent())
  S.tryResolveExplicitSpecifier(Result);
return Result;
576}

578static void instantiateDependentAMDGPUWavesPerEUAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const AMDGPUWavesPerEUAttr &Attr, Decl *New) {
// Both min and max expression are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
if (Result.isInvalid())
  return;
Expr *MinExpr = Result.getAs<Expr>();

Expr *MaxExpr = nullptr;
if (auto Max = Attr.getMax()) {
  Result = S.SubstExpr(Max, TemplateArgs);
  if (Result.isInvalid())
    return;
  MaxExpr = Result.getAs<Expr>();
}

S.addAMDGPUWavesPerEUAttr(New, Attr, MinExpr, MaxExpr);
599}

601// This doesn't take any template parameters, but we have a custom action that
602// needs to happen when the kernel itself is instantiated. We need to run the
603// ItaniumMangler to mark the names required to name this kernel.
604static void instantiateDependentSYCLKernelAttr(
  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
  const SYCLKernelAttr &Attr, Decl *New) {
New->addAttr(Attr.clone(S.getASTContext()));
608}

610/// Determine whether the attribute A might be relevant to the declaration D.
611/// If not, we can skip instantiating it. The attribute may or may not have
612/// been instantiated yet.
613static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A) {
// 'preferred_name' is only relevant to the matching specialization of the
// template.
if (const auto *PNA = dyn_cast<PreferredNameAttr>(A)) {
  QualType T = PNA->getTypedefType();
  const auto *RD = cast<CXXRecordDecl>(D);
  if (!T->isDependentType() && !RD->isDependentContext() &&
      !declaresSameEntity(T->getAsCXXRecordDecl(), RD))
    return false;
  for (const auto *ExistingPNA : D->specific_attrs<PreferredNameAttr>())
    if (S.Context.hasSameType(ExistingPNA->getTypedefType(),
                              PNA->getTypedefType()))
      return false;
  return true;
}

if (const auto *BA = dyn_cast<BuiltinAttr>(A)) {
  const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
  switch (BA->getID()) {
  case Builtin::BIforward:
    // Do not treat 'std::forward' as a builtin if it takes an rvalue reference
    // type and returns an lvalue reference type. The library implementation
    // will produce an error in this case; don't get in its way.
    if (FD && FD->getNumParams() >= 1 &&
        FD->getParamDecl(0)->getType()->isRValueReferenceType() &&
        FD->getReturnType()->isLValueReferenceType()) {
      return false;
    }
    [[fallthrough]];
  case Builtin::BImove:
  case Builtin::BImove_if_noexcept:
    // HACK: Super-old versions of libc++ (3.1 and earlier) provide
    // std::forward and std::move overloads that sometimes return by value
    // instead of by reference when building in C++98 mode. Don't treat such
    // cases as builtins.
    if (FD && !FD->getReturnType()->isReferenceType())
      return false;
    break;
  }
}

return true;
655}

657void Sema::InstantiateAttrsForDecl(
  const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
  Decl *New, LateInstantiatedAttrVec *LateAttrs,
  LocalInstantiationScope *OuterMostScope) {
if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
  // FIXME: This function is called multiple times for the same template
  // specialization. We should only instantiate attributes that were added
  // since the previous instantiation.
  for (const auto *TmplAttr : Tmpl->attrs()) {
    if (!isRelevantAttr(*this, New, TmplAttr))
      continue;

    // FIXME: If any of the special case versions from InstantiateAttrs become
    // applicable to template declaration, we'll need to add them here.
    CXXThisScopeRAII ThisScope(
        *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
        Qualifiers(), ND->isCXXInstanceMember());

    Attr *NewAttr = sema::instantiateTemplateAttributeForDecl(
        TmplAttr, Context, *this, TemplateArgs);
    if (NewAttr && isRelevantAttr(*this, New, NewAttr))
      New->addAttr(NewAttr);
  }
}
681}

683static Sema::RetainOwnershipKind
684attrToRetainOwnershipKind(const Attr *A) {
switch (A->getKind()) {
case clang::attr::CFConsumed:
  return Sema::RetainOwnershipKind::CF;
case clang::attr::OSConsumed:
  return Sema::RetainOwnershipKind::OS;
case clang::attr::NSConsumed:
  return Sema::RetainOwnershipKind::NS;
default:
  llvm_unreachable("Wrong argument supplied")::llvm::llvm_unreachable_internal("Wrong argument supplied", "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 693);
}
695}

697void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
                          const Decl *Tmpl, Decl *New,
                          LateInstantiatedAttrVec *LateAttrs,
                          LocalInstantiationScope *OuterMostScope) {
for (const auto *TmplAttr : Tmpl->attrs()) {
  if (!isRelevantAttr(*this, New, TmplAttr))
    continue;

  // FIXME: This should be generalized to more than just the AlignedAttr.
  const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
  if (Aligned && Aligned->isAlignmentDependent()) {
    instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
    continue;
  }

  if (const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) {
    instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
    continue;
  }

  if (const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
    instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
    continue;
  }

  if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
    instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
    continue;
  }

  if (const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
    instantiateDependentAnnotationAttr(*this, TemplateArgs, Annotate, New);
    continue;
  }

  if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
    instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
                                     cast<FunctionDecl>(New));
    continue;
  }

  if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
    instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
                                       cast<FunctionDecl>(New));
    continue;
  }

  if (const auto *CUDALaunchBounds =
          dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
    instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
                                             *CUDALaunchBounds, New);
    continue;
  }

  if (const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
    instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
    continue;
  }

  if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
    instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
    continue;
  }

  if (const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) {
    instantiateOMPDeclareVariantAttr(*this, TemplateArgs, *OMPAttr, New);
    continue;
  }

  if (const auto *AMDGPUFlatWorkGroupSize =
          dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
    instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
        *this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
  }

  if (const auto *AMDGPUFlatWorkGroupSize =
          dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
    instantiateDependentAMDGPUWavesPerEUAttr(*this, TemplateArgs,
                                             *AMDGPUFlatWorkGroupSize, New);
  }

  // Existing DLL attribute on the instantiation takes precedence.
  if (TmplAttr->getKind() == attr::DLLExport ||
      TmplAttr->getKind() == attr::DLLImport) {
    if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
      continue;
    }
  }

  if (const auto *ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
    AddParameterABIAttr(New, *ABIAttr, ABIAttr->getABI());
    continue;
  }

  if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) ||
      isa<CFConsumedAttr>(TmplAttr)) {
    AddXConsumedAttr(New, *TmplAttr, attrToRetainOwnershipKind(TmplAttr),
                     /*template instantiation=*/true);
    continue;
  }

  if (auto *A = dyn_cast<PointerAttr>(TmplAttr)) {
    if (!New->hasAttr<PointerAttr>())
      New->addAttr(A->clone(Context));
    continue;
  }

  if (auto *A = dyn_cast<OwnerAttr>(TmplAttr)) {
    if (!New->hasAttr<OwnerAttr>())
      New->addAttr(A->clone(Context));
    continue;
  }

  if (auto *A = dyn_cast<SYCLKernelAttr>(TmplAttr)) {
    instantiateDependentSYCLKernelAttr(*this, TemplateArgs, *A, New);
    continue;
  }

  assert(!TmplAttr->isPackExpansion())(static_cast <bool> (!TmplAttr->isPackExpansion()) ?
 void (0) : __assert_fail ("!TmplAttr->isPackExpansion()",
 "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 815, __extension__
 __PRETTY_FUNCTION__));
  if (TmplAttr->isLateParsed() && LateAttrs) {
    // Late parsed attributes must be instantiated and attached after the
    // enclosing class has been instantiated.  See Sema::InstantiateClass.
    LocalInstantiationScope *Saved = nullptr;
    if (CurrentInstantiationScope)
      Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
    LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
  } else {
    // Allow 'this' within late-parsed attributes.
    auto *ND = cast<NamedDecl>(New);
    auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
    CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
                               ND->isCXXInstanceMember());

    Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
                                                       *this, TemplateArgs);
    if (NewAttr && isRelevantAttr(*this, New, TmplAttr))
      New->addAttr(NewAttr);
  }
}
836}

838/// Update instantiation attributes after template was late parsed.
839///
840/// Some attributes are evaluated based on the body of template. If it is
841/// late parsed, such attributes cannot be evaluated when declaration is
842/// instantiated. This function is used to update instantiation attributes when
843/// template definition is ready.
844void Sema::updateAttrsForLateParsedTemplate(const Decl *Pattern, Decl *Inst) {
for (const auto *Attr : Pattern->attrs()) {
  if (auto *A = dyn_cast<StrictFPAttr>(Attr)) {
    if (!Inst->hasAttr<StrictFPAttr>())
      Inst->addAttr(A->clone(getASTContext()));
    continue;
  }
}
852}

854/// In the MS ABI, we need to instantiate default arguments of dllexported
855/// default constructors along with the constructor definition. This allows IR
856/// gen to emit a constructor closure which calls the default constructor with
857/// its default arguments.
858void Sema::InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor) {
assert(Context.getTargetInfo().getCXXABI().isMicrosoft() &&(static_cast <bool> (Context.getTargetInfo().getCXXABI(
).isMicrosoft() && Ctor->isDefaultConstructor()) ?
 void (0) : __assert_fail ("Context.getTargetInfo().getCXXABI().isMicrosoft() && Ctor->isDefaultConstructor()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 860, __extension__
 __PRETTY_FUNCTION__))
       Ctor->isDefaultConstructor())(static_cast <bool> (Context.getTargetInfo().getCXXABI(
).isMicrosoft() && Ctor->isDefaultConstructor()) ?
 void (0) : __assert_fail ("Context.getTargetInfo().getCXXABI().isMicrosoft() && Ctor->isDefaultConstructor()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 860, __extension__
 __PRETTY_FUNCTION__));
unsigned NumParams = Ctor->getNumParams();
if (NumParams == 0)
  return;
DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
if (!Attr)
  return;
for (unsigned I = 0; I != NumParams; ++I) {
  (void)CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
                                 Ctor->getParamDecl(I));
  CleanupVarDeclMarking();
}
872}

874/// Get the previous declaration of a declaration for the purposes of template
875/// instantiation. If this finds a previous declaration, then the previous
876/// declaration of the instantiation of D should be an instantiation of the
877/// result of this function.
878template<typename DeclT>
879static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
DeclT *Result = D->getPreviousDecl();

// If the declaration is within a class, and the previous declaration was
// merged from a different definition of that class, then we don't have a
// previous declaration for the purpose of template instantiation.
if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
    D->getLexicalDeclContext() != Result->getLexicalDeclContext())
  return nullptr;

return Result;
890}

892Decl *
893TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
llvm_unreachable("Translation units cannot be instantiated")::llvm::llvm_unreachable_internal("Translation units cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 894);
895}

897Decl *TemplateDeclInstantiator::VisitHLSLBufferDecl(HLSLBufferDecl *Decl) {
llvm_unreachable("HLSL buffer declarations cannot be instantiated")::llvm::llvm_unreachable_internal("HLSL buffer declarations cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 898);
899}

901Decl *
902TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
llvm_unreachable("pragma comment cannot be instantiated")::llvm::llvm_unreachable_internal("pragma comment cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 903);
904}

906Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
  PragmaDetectMismatchDecl *D) {
llvm_unreachable("pragma comment cannot be instantiated")::llvm::llvm_unreachable_internal("pragma comment cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 908);
909}

911Decl *
912TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
llvm_unreachable("extern \"C\" context cannot be instantiated")::llvm::llvm_unreachable_internal("extern \"C\" context cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 913);
914}

916Decl *TemplateDeclInstantiator::VisitMSGuidDecl(MSGuidDecl *D) {
llvm_unreachable("GUID declaration cannot be instantiated")::llvm::llvm_unreachable_internal("GUID declaration cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 917);
918}

920Decl *TemplateDeclInstantiator::VisitUnnamedGlobalConstantDecl(
  UnnamedGlobalConstantDecl *D) {
llvm_unreachable("UnnamedGlobalConstantDecl cannot be instantiated")::llvm::llvm_unreachable_internal("UnnamedGlobalConstantDecl cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 922);
923}

925Decl *TemplateDeclInstantiator::VisitTemplateParamObjectDecl(
  TemplateParamObjectDecl *D) {
llvm_unreachable("template parameter objects cannot be instantiated")::llvm::llvm_unreachable_internal("template parameter objects cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 927);
928}

930Decl *
931TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                    D->getIdentifier());
Owner->addDecl(Inst);
return Inst;
936}

938Decl *
939TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
llvm_unreachable("Namespaces cannot be instantiated")::llvm::llvm_unreachable_internal("Namespaces cannot be instantiated"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 940);
941}

943Decl *
944TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
NamespaceAliasDecl *Inst
  = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
                               D->getNamespaceLoc(),
                               D->getAliasLoc(),
                               D->getIdentifier(),
                               D->getQualifierLoc(),
                               D->getTargetNameLoc(),
                               D->getNamespace());
Owner->addDecl(Inst);
return Inst;
955}

957Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
                                                         bool IsTypeAlias) {
bool Invalid = false;
TypeSourceInfo *DI = D->getTypeSourceInfo();
if (DI->getType()->isInstantiationDependentType() ||
    DI->getType()->isVariablyModifiedType()) {
  DI = SemaRef.SubstType(DI, TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI) {
    Invalid = true;
    DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
  }
} else {
  SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
}

// HACK: 2012-10-23 g++ has a bug where it gets the value kind of ?: wrong.
// libstdc++ relies upon this bug in its implementation of common_type.  If we
// happen to be processing that implementation, fake up the g++ ?:
// semantics. See LWG issue 2141 for more information on the bug.  The bugs
// are fixed in g++ and libstdc++ 4.9.0 (2014-04-22).
const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
    DT->isReferenceType() &&
    RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
    RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
    D->getIdentifier() && D->getIdentifier()->isStr("type") &&
    SemaRef.getSourceManager().isInSystemHeader(D->getBeginLoc()))
  // Fold it to the (non-reference) type which g++ would have produced.
  DI = SemaRef.Context.getTrivialTypeSourceInfo(
    DI->getType().getNonReferenceType());

// Create the new typedef
TypedefNameDecl *Typedef;
if (IsTypeAlias)
  Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
                                  D->getLocation(), D->getIdentifier(), DI);
else
  Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
                                D->getLocation(), D->getIdentifier(), DI);
if (Invalid)
  Typedef->setInvalidDecl();

// If the old typedef was the name for linkage purposes of an anonymous
// tag decl, re-establish that relationship for the new typedef.
if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
  TagDecl *oldTag = oldTagType->getDecl();
  if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
    TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
    assert(!newTag->hasNameForLinkage())(static_cast <bool> (!newTag->hasNameForLinkage()) ?
 void (0) : __assert_fail ("!newTag->hasNameForLinkage()",
 "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1007, __extension__
 __PRETTY_FUNCTION__));
    newTag->setTypedefNameForAnonDecl(Typedef);
  }
}

if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) {
  NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
                                                     TemplateArgs);
  if (!InstPrev)
    return nullptr;

  TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);

  // If the typedef types are not identical, reject them.
  SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);

  Typedef->setPreviousDecl(InstPrevTypedef);
}

SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);

if (D->getUnderlyingType()->getAs<DependentNameType>())
  SemaRef.inferGslPointerAttribute(Typedef);

Typedef->setAccess(D->getAccess());
Typedef->setReferenced(D->isReferenced());

return Typedef;
1035}

1037Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
if (Typedef)
  Owner->addDecl(Typedef);
return Typedef;
1042}

1044Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
if (Typedef)
  Owner->addDecl(Typedef);
return Typedef;
1049}

1051Decl *
1052TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
// Create a local instantiation scope for this type alias template, which
// will contain the instantiations of the template parameters.
LocalInstantiationScope Scope(SemaRef);

TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

TypeAliasDecl *Pattern = D->getTemplatedDecl();

TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
  if (!Found.empty()) {
    PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
  }
}

TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
  InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
if (!AliasInst)
  return nullptr;

TypeAliasTemplateDecl *Inst
  = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                  D->getDeclName(), InstParams, AliasInst);
AliasInst->setDescribedAliasTemplate(Inst);
if (PrevAliasTemplate)
  Inst->setPreviousDecl(PrevAliasTemplate);

Inst->setAccess(D->getAccess());

if (!PrevAliasTemplate)
  Inst->setInstantiatedFromMemberTemplate(D);

Owner->addDecl(Inst);

return Inst;
1092}

1094Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                  D->getIdentifier());
NewBD->setReferenced(D->isReferenced());
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
return NewBD;
1100}

1102Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
// Transform the bindings first.
SmallVector<BindingDecl*, 16> NewBindings;
for (auto *OldBD : D->bindings())
  NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
ArrayRef<BindingDecl*> NewBindingArray = NewBindings;

auto *NewDD = cast_or_null<DecompositionDecl>(
    VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));

if (!NewDD || NewDD->isInvalidDecl())
  for (auto *NewBD : NewBindings)
    NewBD->setInvalidDecl();

return NewDD;
1117}

1119Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
1121}

1123Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
                                           bool InstantiatingVarTemplate,
                                           ArrayRef<BindingDecl*> *Bindings) {

// Do substitution on the type of the declaration
TypeSourceInfo *DI = SemaRef.SubstType(
    D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
    D->getDeclName(), /*AllowDeducedTST*/true);
if (!DI)
  return nullptr;

if (DI->getType()->isFunctionType()) {
  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
    << D->isStaticDataMember() << DI->getType();
  return nullptr;
}

DeclContext *DC = Owner;
if (D->isLocalExternDecl())
  SemaRef.adjustContextForLocalExternDecl(DC);

// Build the instantiated declaration.
VarDecl *Var;
if (Bindings)
  Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
                                  D->getLocation(), DI->getType(), DI,
                                  D->getStorageClass(), *Bindings);
else
  Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
                        D->getLocation(), D->getIdentifier(), DI->getType(),
                        DI, D->getStorageClass());

// In ARC, infer 'retaining' for variables of retainable type.
if (SemaRef.getLangOpts().ObjCAutoRefCount &&
    SemaRef.inferObjCARCLifetime(Var))
  Var->setInvalidDecl();

if (SemaRef.getLangOpts().OpenCL)
  SemaRef.deduceOpenCLAddressSpace(Var);

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, Var))
  return nullptr;

SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
                                   StartingScope, InstantiatingVarTemplate);
if (D->isNRVOVariable() && !Var->isInvalidDecl()) {
  QualType RT;
  if (auto *F = dyn_cast<FunctionDecl>(DC))
    RT = F->getReturnType();
  else if (isa<BlockDecl>(DC))
    RT = cast<FunctionType>(SemaRef.getCurBlock()->FunctionType)
             ->getReturnType();
  else
    llvm_unreachable("Unknown context type")::llvm::llvm_unreachable_internal("Unknown context type", "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1177);

  // This is the last chance we have of checking copy elision eligibility
  // for functions in dependent contexts. The sema actions for building
  // the return statement during template instantiation will have no effect
  // regarding copy elision, since NRVO propagation runs on the scope exit
  // actions, and these are not run on instantiation.
  // This might run through some VarDecls which were returned from non-taken
  // 'if constexpr' branches, and these will end up being constructed on the
  // return slot even if they will never be returned, as a sort of accidental
  // 'optimization'. Notably, functions with 'auto' return types won't have it
  // deduced by this point. Coupled with the limitation described
  // previously, this makes it very hard to support copy elision for these.
  Sema::NamedReturnInfo Info = SemaRef.getNamedReturnInfo(Var);
  bool NRVO = SemaRef.getCopyElisionCandidate(Info, RT) != nullptr;
  Var->setNRVOVariable(NRVO);
}

Var->setImplicit(D->isImplicit());

if (Var->isStaticLocal())
  SemaRef.CheckStaticLocalForDllExport(Var);

if (Var->getTLSKind())
  SemaRef.CheckThreadLocalForLargeAlignment(Var);

return Var;
1204}

1206Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
AccessSpecDecl* AD
  = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
                           D->getAccessSpecifierLoc(), D->getColonLoc());
Owner->addHiddenDecl(AD);
return AD;
1212}

1214Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
bool Invalid = false;
TypeSourceInfo *DI = D->getTypeSourceInfo();
if (DI->getType()->isInstantiationDependentType() ||
    DI->getType()->isVariablyModifiedType())  {
  DI = SemaRef.SubstType(DI, TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI) {
    DI = D->getTypeSourceInfo();
    Invalid = true;
  } else if (DI->getType()->isFunctionType()) {
    // C++ [temp.arg.type]p3:
    //   If a declaration acquires a function type through a type
    //   dependent on a template-parameter and this causes a
    //   declaration that does not use the syntactic form of a
    //   function declarator to have function type, the program is
    //   ill-formed.
    SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
      << DI->getType();
    Invalid = true;
  }
} else {
  SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
}

Expr *BitWidth = D->getBitWidth();
if (Invalid)
  BitWidth = nullptr;
else if (BitWidth) {
  // The bit-width expression is a constant expression.
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  ExprResult InstantiatedBitWidth
    = SemaRef.SubstExpr(BitWidth, TemplateArgs);
  if (InstantiatedBitWidth.isInvalid()) {
    Invalid = true;
    BitWidth = nullptr;
  } else
    BitWidth = InstantiatedBitWidth.getAs<Expr>();
}

FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
                                          DI->getType(), DI,
                                          cast<RecordDecl>(Owner),
                                          D->getLocation(),
                                          D->isMutable(),
                                          BitWidth,
                                          D->getInClassInitStyle(),
                                          D->getInnerLocStart(),
                                          D->getAccess(),
                                          nullptr);
if (!Field) {
  cast<Decl>(Owner)->setInvalidDecl();
  return nullptr;
}

SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);

if (Field->hasAttrs())
  SemaRef.CheckAlignasUnderalignment(Field);

if (Invalid)
  Field->setInvalidDecl();

if (!Field->getDeclName()) {
  // Keep track of where this decl came from.
  SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
}
if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
  if (Parent->isAnonymousStructOrUnion() &&
      Parent->getRedeclContext()->isFunctionOrMethod())
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
}

Field->setImplicit(D->isImplicit());
Field->setAccess(D->getAccess());
Owner->addDecl(Field);

return Field;
1294}

1296Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
bool Invalid = false;
TypeSourceInfo *DI = D->getTypeSourceInfo();

if (DI->getType()->isVariablyModifiedType()) {
  SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
    << D;
  Invalid = true;
} else if (DI->getType()->isInstantiationDependentType())  {
  DI = SemaRef.SubstType(DI, TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI) {
    DI = D->getTypeSourceInfo();
    Invalid = true;
  } else if (DI->getType()->isFunctionType()) {
    // C++ [temp.arg.type]p3:
    //   If a declaration acquires a function type through a type
    //   dependent on a template-parameter and this causes a
    //   declaration that does not use the syntactic form of a
    //   function declarator to have function type, the program is
    //   ill-formed.
    SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
    << DI->getType();
    Invalid = true;
  }
} else {
  SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
}

MSPropertyDecl *Property = MSPropertyDecl::Create(
    SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
    DI, D->getBeginLoc(), D->getGetterId(), D->getSetterId());

SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
                         StartingScope);

if (Invalid)
  Property->setInvalidDecl();

Property->setAccess(D->getAccess());
Owner->addDecl(Property);

return Property;
1339}

1341Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
NamedDecl **NamedChain =
  new (SemaRef.Context)NamedDecl*[D->getChainingSize()];

int i = 0;
for (auto *PI : D->chain()) {
  NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
                                            TemplateArgs);
  if (!Next)
    return nullptr;

  NamedChain[i++] = Next;
}

QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
    SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
    {NamedChain, D->getChainingSize()});

for (const auto *Attr : D->attrs())
  IndirectField->addAttr(Attr->clone(SemaRef.Context));

IndirectField->setImplicit(D->isImplicit());
IndirectField->setAccess(D->getAccess());
Owner->addDecl(IndirectField);
return IndirectField;
1367}

1369Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
// Handle friend type expressions by simply substituting template
// parameters into the pattern type and checking the result.
if (TypeSourceInfo *Ty = D->getFriendType()) {
  TypeSourceInfo *InstTy;
  // If this is an unsupported friend, don't bother substituting template
  // arguments into it. The actual type referred to won't be used by any
  // parts of Clang, and may not be valid for instantiating. Just use the
  // same info for the instantiated friend.
  if (D->isUnsupportedFriend()) {
    InstTy = Ty;
  } else {
    InstTy = SemaRef.SubstType(Ty, TemplateArgs,
                               D->getLocation(), DeclarationName());
  }
  if (!InstTy)
    return nullptr;

  FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getBeginLoc(),
                                               D->getFriendLoc(), InstTy);
  if (!FD)
    return nullptr;

  FD->setAccess(AS_public);
  FD->setUnsupportedFriend(D->isUnsupportedFriend());
  Owner->addDecl(FD);
  return FD;
}

NamedDecl *ND = D->getFriendDecl();
assert(ND && "friend decl must be a decl or a type!")(static_cast <bool> (ND && "friend decl must be a decl or a type!"
) ? void (0) : __assert_fail ("ND && \"friend decl must be a decl or a type!\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1399, __extension__
 __PRETTY_FUNCTION__));

// All of the Visit implementations for the various potential friend
// declarations have to be carefully written to work for friend
// objects, with the most important detail being that the target
// decl should almost certainly not be placed in Owner.
Decl *NewND = Visit(ND);
if (!NewND) return nullptr;

FriendDecl *FD =
  FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                     cast<NamedDecl>(NewND), D->getFriendLoc());
FD->setAccess(AS_public);
FD->setUnsupportedFriend(D->isUnsupportedFriend());
Owner->addDecl(FD);
return FD;
1415}

1417Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
Expr *AssertExpr = D->getAssertExpr();

// The expression in a static assertion is a constant expression.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult InstantiatedAssertExpr
  = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
if (InstantiatedAssertExpr.isInvalid())
  return nullptr;

return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
                                            InstantiatedAssertExpr.get(),
                                            D->getMessage(),
                                            D->getRParenLoc(),
                                            D->isFailed());
1434}

1436Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
EnumDecl *PrevDecl = nullptr;
if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                                 PatternPrev,
                                                 TemplateArgs);
  if (!Prev) return nullptr;
  PrevDecl = cast<EnumDecl>(Prev);
}

EnumDecl *Enum =
    EnumDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
                     D->getLocation(), D->getIdentifier(), PrevDecl,
                     D->isScoped(), D->isScopedUsingClassTag(), D->isFixed());
if (D->isFixed()) {
  if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
    // If we have type source information for the underlying type, it means it
    // has been explicitly set by the user. Perform substitution on it before
    // moving on.
    SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
    TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
                                              DeclarationName());
    if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
      Enum->setIntegerType(SemaRef.Context.IntTy);
    else
      Enum->setIntegerTypeSourceInfo(NewTI);
  } else {
    assert(!D->getIntegerType()->isDependentType()(static_cast <bool> (!D->getIntegerType()->isDependentType
() && "Dependent type without type source info") ? void
 (0) : __assert_fail ("!D->getIntegerType()->isDependentType() && \"Dependent type without type source info\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1464, __extension__
 __PRETTY_FUNCTION__))
           && "Dependent type without type source info")(static_cast <bool> (!D->getIntegerType()->isDependentType
() && "Dependent type without type source info") ? void
 (0) : __assert_fail ("!D->getIntegerType()->isDependentType() && \"Dependent type without type source info\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1464, __extension__
 __PRETTY_FUNCTION__));
    Enum->setIntegerType(D->getIntegerType());
  }
}

SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);

Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
Enum->setAccess(D->getAccess());
// Forward the mangling number from the template to the instantiated decl.
SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
// See if the old tag was defined along with a declarator.
// If it did, mark the new tag as being associated with that declarator.
if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
// See if the old tag was defined along with a typedef.
// If it did, mark the new tag as being associated with that typedef.
if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
if (SubstQualifier(D, Enum)) return nullptr;
Owner->addDecl(Enum);

EnumDecl *Def = D->getDefinition();
if (Def && Def != D) {
  // If this is an out-of-line definition of an enum member template, check
  // that the underlying types match in the instantiation of both
  // declarations.
  if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
    SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
    QualType DefnUnderlying =
      SemaRef.SubstType(TI->getType(), TemplateArgs,
                        UnderlyingLoc, DeclarationName());
    SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
                                   DefnUnderlying, /*IsFixed=*/true, Enum);
  }
}

// C++11 [temp.inst]p1: The implicit instantiation of a class template
// specialization causes the implicit instantiation of the declarations, but
// not the definitions of scoped member enumerations.
//
// DR1484 clarifies that enumeration definitions inside of a template
// declaration aren't considered entities that can be separately instantiated
// from the rest of the entity they are declared inside of.
if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
  InstantiateEnumDefinition(Enum, Def);
}

return Enum;
1514}

1516void TemplateDeclInstantiator::InstantiateEnumDefinition(
  EnumDecl *Enum, EnumDecl *Pattern) {
Enum->startDefinition();

// Update the location to refer to the definition.
Enum->setLocation(Pattern->getLocation());

SmallVector<Decl*, 4> Enumerators;

EnumConstantDecl *LastEnumConst = nullptr;
for (auto *EC : Pattern->enumerators()) {
  // The specified value for the enumerator.
  ExprResult Value((Expr *)nullptr);
  if (Expr *UninstValue = EC->getInitExpr()) {
    // The enumerator's value expression is a constant expression.
    EnterExpressionEvaluationContext Unevaluated(
        SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

    Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
  }

  // Drop the initial value and continue.
  bool isInvalid = false;
  if (Value.isInvalid()) {
    Value = nullptr;
    isInvalid = true;
  }

  EnumConstantDecl *EnumConst
    = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
                                EC->getLocation(), EC->getIdentifier(),
                                Value.get());

  if (isInvalid) {
    if (EnumConst)
      EnumConst->setInvalidDecl();
    Enum->setInvalidDecl();
  }

  if (EnumConst) {
    SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);

    EnumConst->setAccess(Enum->getAccess());
    Enum->addDecl(EnumConst);
    Enumerators.push_back(EnumConst);
    LastEnumConst = EnumConst;

    if (Pattern->getDeclContext()->isFunctionOrMethod() &&
        !Enum->isScoped()) {
      // If the enumeration is within a function or method, record the enum
      // constant as a local.
      SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
    }
  }
}

SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
                      Enumerators, nullptr, ParsedAttributesView());
1574}

1576Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.")::llvm::llvm_unreachable_internal("EnumConstantDecls can only occur within EnumDecls."
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1577);
1578}

1580Decl *
1581TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.")::llvm::llvm_unreachable_internal("BuiltinTemplateDecls cannot be instantiated."
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1582);
1583}

1585Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);

// Create a local instantiation scope for this class template, which
// will contain the instantiations of the template parameters.
LocalInstantiationScope Scope(SemaRef);
TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

CXXRecordDecl *Pattern = D->getTemplatedDecl();

// Instantiate the qualifier.  We have to do this first in case
// we're a friend declaration, because if we are then we need to put
// the new declaration in the appropriate context.
NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                     TemplateArgs);
  if (!QualifierLoc)
    return nullptr;
}

CXXRecordDecl *PrevDecl = nullptr;
ClassTemplateDecl *PrevClassTemplate = nullptr;

if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
  if (!Found.empty()) {
    PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
    if (PrevClassTemplate)
      PrevDecl = PrevClassTemplate->getTemplatedDecl();
  }
}

// If this isn't a friend, then it's a member template, in which
// case we just want to build the instantiation in the
// specialization.  If it is a friend, we want to build it in
// the appropriate context.
DeclContext *DC = Owner;
if (isFriend) {
  if (QualifierLoc) {
    CXXScopeSpec SS;
    SS.Adopt(QualifierLoc);
    DC = SemaRef.computeDeclContext(SS);
    if (!DC) return nullptr;
  } else {
    DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
                                         Pattern->getDeclContext(),
                                         TemplateArgs);
  }

  // Look for a previous declaration of the template in the owning
  // context.
  LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
                 Sema::LookupOrdinaryName,
                 SemaRef.forRedeclarationInCurContext());
  SemaRef.LookupQualifiedName(R, DC);

  if (R.isSingleResult()) {
    PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
    if (PrevClassTemplate)
      PrevDecl = PrevClassTemplate->getTemplatedDecl();
  }

  if (!PrevClassTemplate && QualifierLoc) {
    SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
      << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
      << QualifierLoc.getSourceRange();
    return nullptr;
  }
}

CXXRecordDecl *RecordInst = CXXRecordDecl::Create(
    SemaRef.Context, Pattern->getTagKind(), DC, Pattern->getBeginLoc(),
    Pattern->getLocation(), Pattern->getIdentifier(), PrevDecl,
    /*DelayTypeCreation=*/true);
if (QualifierLoc)
  RecordInst->setQualifierInfo(QualifierLoc);

SemaRef.InstantiateAttrsForDecl(TemplateArgs, Pattern, RecordInst, LateAttrs,
                                                            StartingScope);

ClassTemplateDecl *Inst
  = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
                              D->getIdentifier(), InstParams, RecordInst);
RecordInst->setDescribedClassTemplate(Inst);

if (isFriend) {
  assert(!Owner->isDependentContext())(static_cast <bool> (!Owner->isDependentContext()) ?
 void (0) : __assert_fail ("!Owner->isDependentContext()",
 "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1675, __extension__
 __PRETTY_FUNCTION__));
  Inst->setLexicalDeclContext(Owner);
  RecordInst->setLexicalDeclContext(Owner);

  if (PrevClassTemplate) {
    Inst->setCommonPtr(PrevClassTemplate->getCommonPtr());
    RecordInst->setTypeForDecl(
        PrevClassTemplate->getTemplatedDecl()->getTypeForDecl());
    const ClassTemplateDecl *MostRecentPrevCT =
        PrevClassTemplate->getMostRecentDecl();
    TemplateParameterList *PrevParams =
        MostRecentPrevCT->getTemplateParameters();

    // Make sure the parameter lists match.
    if (!SemaRef.TemplateParameterListsAreEqual(
            RecordInst, InstParams, MostRecentPrevCT->getTemplatedDecl(),
            PrevParams, true, Sema::TPL_TemplateMatch))
      return nullptr;

    // Do some additional validation, then merge default arguments
    // from the existing declarations.
    if (SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
                                           Sema::TPC_ClassTemplate))
      return nullptr;

    Inst->setAccess(PrevClassTemplate->getAccess());
  } else {
    Inst->setAccess(D->getAccess());
  }

  Inst->setObjectOfFriendDecl();
  // TODO: do we want to track the instantiation progeny of this
  // friend target decl?
} else {
  Inst->setAccess(D->getAccess());
  if (!PrevClassTemplate)
    Inst->setInstantiatedFromMemberTemplate(D);
}

Inst->setPreviousDecl(PrevClassTemplate);

// Trigger creation of the type for the instantiation.
SemaRef.Context.getInjectedClassNameType(
    RecordInst, Inst->getInjectedClassNameSpecialization());

// Finish handling of friends.
if (isFriend) {
  DC->makeDeclVisibleInContext(Inst);
  return Inst;
}

if (D->isOutOfLine()) {
  Inst->setLexicalDeclContext(D->getLexicalDeclContext());
  RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
}

Owner->addDecl(Inst);

if (!PrevClassTemplate) {
  // Queue up any out-of-line partial specializations of this member
  // class template; the client will force their instantiation once
  // the enclosing class has been instantiated.
  SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  D->getPartialSpecializations(PartialSpecs);
  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
    if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
      OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
}

return Inst;
1745}

1747Decl *
1748TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
                                 ClassTemplatePartialSpecializationDecl *D) {
ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();

// Lookup the already-instantiated declaration in the instantiation
// of the class template and return that.
DeclContext::lookup_result Found
  = Owner->lookup(ClassTemplate->getDeclName());
if (Found.empty())
  return nullptr;

ClassTemplateDecl *InstClassTemplate
  = dyn_cast<ClassTemplateDecl>(Found.front());
if (!InstClassTemplate)
  return nullptr;

if (ClassTemplatePartialSpecializationDecl *Result
      = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
  return Result;

return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
1769}

1771Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
assert(D->getTemplatedDecl()->isStaticDataMember() &&(static_cast <bool> (D->getTemplatedDecl()->isStaticDataMember
() && "Only static data member templates are allowed."
) ? void (0) : __assert_fail ("D->getTemplatedDecl()->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1773, __extension__
 __PRETTY_FUNCTION__))
       "Only static data member templates are allowed.")(static_cast <bool> (D->getTemplatedDecl()->isStaticDataMember
() && "Only static data member templates are allowed."
) ? void (0) : __assert_fail ("D->getTemplatedDecl()->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1773, __extension__
 __PRETTY_FUNCTION__));

// Create a local instantiation scope for this variable template, which
// will contain the instantiations of the template parameters.
LocalInstantiationScope Scope(SemaRef);
TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

VarDecl *Pattern = D->getTemplatedDecl();
VarTemplateDecl *PrevVarTemplate = nullptr;

if (getPreviousDeclForInstantiation(Pattern)) {
  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
  if (!Found.empty())
    PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
}

VarDecl *VarInst =
    cast_or_null<VarDecl>(VisitVarDecl(Pattern,
                                       /*InstantiatingVarTemplate=*/true));
if (!VarInst) return nullptr;

DeclContext *DC = Owner;

VarTemplateDecl *Inst = VarTemplateDecl::Create(
    SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
    VarInst);
VarInst->setDescribedVarTemplate(Inst);
Inst->setPreviousDecl(PrevVarTemplate);

Inst->setAccess(D->getAccess());
if (!PrevVarTemplate)
  Inst->setInstantiatedFromMemberTemplate(D);

if (D->isOutOfLine()) {
  Inst->setLexicalDeclContext(D->getLexicalDeclContext());
  VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
}

Owner->addDecl(Inst);

if (!PrevVarTemplate) {
  // Queue up any out-of-line partial specializations of this member
  // variable template; the client will force their instantiation once
  // the enclosing class has been instantiated.
  SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  D->getPartialSpecializations(PartialSpecs);
  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
    if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
      OutOfLineVarPartialSpecs.push_back(
          std::make_pair(Inst, PartialSpecs[I]));
}

return Inst;
1829}

1831Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
  VarTemplatePartialSpecializationDecl *D) {
assert(D->isStaticDataMember() &&(static_cast <bool> (D->isStaticDataMember() &&
 "Only static data member templates are allowed.") ? void (0)
 : __assert_fail ("D->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1834, __extension__
 __PRETTY_FUNCTION__))
       "Only static data member templates are allowed.")(static_cast <bool> (D->isStaticDataMember() &&
 "Only static data member templates are allowed.") ? void (0)
 : __assert_fail ("D->isStaticDataMember() && \"Only static data member templates are allowed.\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1834, __extension__
 __PRETTY_FUNCTION__));

VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();

// Lookup the already-instantiated declaration and return that.
DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
assert(!Found.empty() && "Instantiation found nothing?")(static_cast <bool> (!Found.empty() && "Instantiation found nothing?"
) ? void (0) : __assert_fail ("!Found.empty() && \"Instantiation found nothing?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1840, __extension__
 __PRETTY_FUNCTION__));

VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
assert(InstVarTemplate && "Instantiation did not find a variable template?")(static_cast <bool> (InstVarTemplate && "Instantiation did not find a variable template?"
) ? void (0) : __assert_fail ("InstVarTemplate && \"Instantiation did not find a variable template?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1843, __extension__
 __PRETTY_FUNCTION__));

if (VarTemplatePartialSpecializationDecl *Result =
        InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
  return Result;

return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1850}

1852Decl *
1853TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
// Create a local instantiation scope for this function template, which
// will contain the instantiations of the template parameters and then get
// merged with the local instantiation scope for the function template
// itself.
LocalInstantiationScope Scope(SemaRef);
Sema::ConstraintEvalRAII<TemplateDeclInstantiator> RAII(*this);

TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

FunctionDecl *Instantiated = nullptr;
if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
  Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
                                                               InstParams));
else
  Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
                                                        D->getTemplatedDecl(),
                                                              InstParams));

if (!Instantiated)
  return nullptr;

// Link the instantiated function template declaration to the function
// template from which it was instantiated.
FunctionTemplateDecl *InstTemplate
  = Instantiated->getDescribedFunctionTemplate();
InstTemplate->setAccess(D->getAccess());
assert(InstTemplate &&(static_cast <bool> (InstTemplate && "VisitFunctionDecl/CXXMethodDecl didn't create a template!"
) ? void (0) : __assert_fail ("InstTemplate && \"VisitFunctionDecl/CXXMethodDecl didn't create a template!\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1884, __extension__
 __PRETTY_FUNCTION__))
       "VisitFunctionDecl/CXXMethodDecl didn't create a template!")(static_cast <bool> (InstTemplate && "VisitFunctionDecl/CXXMethodDecl didn't create a template!"
) ? void (0) : __assert_fail ("InstTemplate && \"VisitFunctionDecl/CXXMethodDecl didn't create a template!\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1884, __extension__
 __PRETTY_FUNCTION__));

bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);

// Link the instantiation back to the pattern *unless* this is a
// non-definition friend declaration.
if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
    !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
  InstTemplate->setInstantiatedFromMemberTemplate(D);

// Make declarations visible in the appropriate context.
if (!isFriend) {
  Owner->addDecl(InstTemplate);
} else if (InstTemplate->getDeclContext()->isRecord() &&
           !getPreviousDeclForInstantiation(D)) {
  SemaRef.CheckFriendAccess(InstTemplate);
}

return InstTemplate;
1903}

1905Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
CXXRecordDecl *PrevDecl = nullptr;
if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                                 PatternPrev,
                                                 TemplateArgs);
  if (!Prev) return nullptr;
  PrevDecl = cast<CXXRecordDecl>(Prev);
}

CXXRecordDecl *Record = nullptr;
bool IsInjectedClassName = D->isInjectedClassName();
if (D->isLambda())
  Record = CXXRecordDecl::CreateLambda(
      SemaRef.Context, Owner, D->getLambdaTypeInfo(), D->getLocation(),
      D->getLambdaDependencyKind(), D->isGenericLambda(),
      D->getLambdaCaptureDefault());
else
  Record = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
                                 D->getBeginLoc(), D->getLocation(),
                                 D->getIdentifier(), PrevDecl,
                                 /*DelayTypeCreation=*/IsInjectedClassName);
// Link the type of the injected-class-name to that of the outer class.
if (IsInjectedClassName)
  (void)SemaRef.Context.getTypeDeclType(Record, cast<CXXRecordDecl>(Owner));

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, Record))
  return nullptr;

SemaRef.InstantiateAttrsForDecl(TemplateArgs, D, Record, LateAttrs,
                                                            StartingScope);

Record->setImplicit(D->isImplicit());
// FIXME: Check against AS_none is an ugly hack to work around the issue that
// the tag decls introduced by friend class declarations don't have an access
// specifier. Remove once this area of the code gets sorted out.
if (D->getAccess() != AS_none)
  Record->setAccess(D->getAccess());
if (!IsInjectedClassName)
  Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);

// If the original function was part of a friend declaration,
// inherit its namespace state.
if (D->getFriendObjectKind())
  Record->setObjectOfFriendDecl();

// Make sure that anonymous structs and unions are recorded.
if (D->isAnonymousStructOrUnion())
  Record->setAnonymousStructOrUnion(true);

if (D->isLocalClass())
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);

// Forward the mangling number from the template to the instantiated decl.
SemaRef.Context.setManglingNumber(Record,
                                  SemaRef.Context.getManglingNumber(D));

// See if the old tag was defined along with a declarator.
// If it did, mark the new tag as being associated with that declarator.
if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);

// See if the old tag was defined along with a typedef.
// If it did, mark the new tag as being associated with that typedef.
if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);

Owner->addDecl(Record);

// DR1484 clarifies that the members of a local class are instantiated as part
// of the instantiation of their enclosing entity.
if (D->isCompleteDefinition() && D->isLocalClass()) {
  Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);

  SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
                           TSK_ImplicitInstantiation,
                           /*Complain=*/true);

  // For nested local classes, we will instantiate the members when we
  // reach the end of the outermost (non-nested) local class.
  if (!D->isCXXClassMember())
    SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
                                    TSK_ImplicitInstantiation);

  // This class may have local implicit instantiations that need to be
  // performed within this scope.
  LocalInstantiations.perform();
}

SemaRef.DiagnoseUnusedNestedTypedefs(Record);

if (IsInjectedClassName)
  assert(Record->isInjectedClassName() && "Broken injected-class-name")(static_cast <bool> (Record->isInjectedClassName() &&
 "Broken injected-class-name") ? void (0) : __assert_fail ("Record->isInjectedClassName() && \"Broken injected-class-name\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 1998, __extension__
 __PRETTY_FUNCTION__));

return Record;
2001}

2003/// Adjust the given function type for an instantiation of the
2004/// given declaration, to cope with modifications to the function's type that
2005/// aren't reflected in the type-source information.
2006///
2007/// \param D The declaration we're instantiating.
2008/// \param TInfo The already-instantiated type.
2009static QualType adjustFunctionTypeForInstantiation(ASTContext &Context,
                                                 FunctionDecl *D,
                                                 TypeSourceInfo *TInfo) {
const FunctionProtoType *OrigFunc
  = D->getType()->castAs<FunctionProtoType>();
const FunctionProtoType *NewFunc
  = TInfo->getType()->castAs<FunctionProtoType>();
if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
  return TInfo->getType();

FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
NewEPI.ExtInfo = OrigFunc->getExtInfo();
return Context.getFunctionType(NewFunc->getReturnType(),
                               NewFunc->getParamTypes(), NewEPI);
2023}

2025/// Normal class members are of more specific types and therefore
2026/// don't make it here.  This function serves three purposes:
2027///   1) instantiating function templates
2028///   2) substituting friend and local function declarations
2029///   3) substituting deduction guide declarations for nested class templates
2030Decl *TemplateDeclInstantiator::VisitFunctionDecl(
  FunctionDecl *D, TemplateParameterList *TemplateParams,
  RewriteKind FunctionRewriteKind) {
// Check whether there is already a function template specialization for
// this declaration.
FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
if (FunctionTemplate && !TemplateParams) {
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();

  void *InsertPos = nullptr;
  FunctionDecl *SpecFunc
    = FunctionTemplate->findSpecialization(Innermost, InsertPos);

  // If we already have a function template specialization, return it.
  if (SpecFunc)
    return SpecFunc;
}

bool isFriend;
if (FunctionTemplate)
  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
else
  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);

bool MergeWithParentScope = (TemplateParams != nullptr) ||
  Owner->isFunctionOrMethod() ||
  !(isa<Decl>(Owner) &&
    cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);

ExplicitSpecifier InstantiatedExplicitSpecifier;
if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
  InstantiatedExplicitSpecifier = instantiateExplicitSpecifier(
      SemaRef, TemplateArgs, DGuide->getExplicitSpecifier(), DGuide);
  if (InstantiatedExplicitSpecifier.isInvalid())
    return nullptr;
}

SmallVector<ParmVarDecl *, 4> Params;
TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
if (!TInfo)
  return nullptr;
QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);

if (TemplateParams && TemplateParams->size()) {
  auto *LastParam =
      dyn_cast<TemplateTypeParmDecl>(TemplateParams->asArray().back());
  if (LastParam && LastParam->isImplicit() &&
      LastParam->hasTypeConstraint()) {
    // In abbreviated templates, the type-constraints of invented template
    // type parameters are instantiated with the function type, invalidating
    // the TemplateParameterList which relied on the template type parameter
    // not having a type constraint. Recreate the TemplateParameterList with
    // the updated parameter list.
    TemplateParams = TemplateParameterList::Create(
        SemaRef.Context, TemplateParams->getTemplateLoc(),
        TemplateParams->getLAngleLoc(), TemplateParams->asArray(),
        TemplateParams->getRAngleLoc(), TemplateParams->getRequiresClause());
  }
}

NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                     TemplateArgs);
  if (!QualifierLoc)
    return nullptr;
}

Expr *TrailingRequiresClause = D->getTrailingRequiresClause();

// If we're instantiating a local function declaration, put the result
// in the enclosing namespace; otherwise we need to find the instantiated
// context.
DeclContext *DC;
if (D->isLocalExternDecl()) {
  DC = Owner;
  SemaRef.adjustContextForLocalExternDecl(DC);
} else if (isFriend && QualifierLoc) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  DC = SemaRef.computeDeclContext(SS);
  if (!DC) return nullptr;
} else {
  DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
                                       TemplateArgs);
}

DeclarationNameInfo NameInfo
  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);

if (FunctionRewriteKind != RewriteKind::None)
  adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);

FunctionDecl *Function;
if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
  Function = CXXDeductionGuideDecl::Create(
      SemaRef.Context, DC, D->getInnerLocStart(),
      InstantiatedExplicitSpecifier, NameInfo, T, TInfo,
      D->getSourceRange().getEnd());
  if (DGuide->isCopyDeductionCandidate())
    cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
  Function->setAccess(D->getAccess());
} else {
  Function = FunctionDecl::Create(
      SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
      D->getCanonicalDecl()->getStorageClass(), D->UsesFPIntrin(),
      D->isInlineSpecified(), D->hasWrittenPrototype(), D->getConstexprKind(),
      TrailingRequiresClause);
  Function->setFriendConstraintRefersToEnclosingTemplate(
      D->FriendConstraintRefersToEnclosingTemplate());
  Function->setRangeEnd(D->getSourceRange().getEnd());
}

if (D->isInlined())
  Function->setImplicitlyInline();

if (QualifierLoc)
  Function->setQualifierInfo(QualifierLoc);

if (D->isLocalExternDecl())
  Function->setLocalExternDecl();

DeclContext *LexicalDC = Owner;
if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
  assert(D->getDeclContext()->isFileContext())(static_cast <bool> (D->getDeclContext()->isFileContext
()) ? void (0) : __assert_fail ("D->getDeclContext()->isFileContext()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2155, __extension__
 __PRETTY_FUNCTION__));
  LexicalDC = D->getDeclContext();
}
else if (D->isLocalExternDecl()) {
  LexicalDC = SemaRef.CurContext;
}

Function->setLexicalDeclContext(LexicalDC);

// Attach the parameters
for (unsigned P = 0; P < Params.size(); ++P)
  if (Params[P])
    Params[P]->setOwningFunction(Function);
Function->setParams(Params);

if (TrailingRequiresClause)
  Function->setTrailingRequiresClause(TrailingRequiresClause);

if (TemplateParams) {
  // Our resulting instantiation is actually a function template, since we
  // are substituting only the outer template parameters. For example, given
  //
  //   template<typename T>
  //   struct X {
  //     template<typename U> friend void f(T, U);
  //   };
  //
  //   X<int> x;
  //
  // We are instantiating the friend function template "f" within X<int>,
  // which means substituting int for T, but leaving "f" as a friend function
  // template.
  // Build the function template itself.
  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
                                                  Function->getLocation(),
                                                  Function->getDeclName(),
                                                  TemplateParams, Function);
  Function->setDescribedFunctionTemplate(FunctionTemplate);

  FunctionTemplate->setLexicalDeclContext(LexicalDC);

  if (isFriend && D->isThisDeclarationADefinition()) {
    FunctionTemplate->setInstantiatedFromMemberTemplate(
                                         D->getDescribedFunctionTemplate());
  }
} else if (FunctionTemplate) {
  // Record this function template specialization.
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
  Function->setFunctionTemplateSpecialization(FunctionTemplate,
                          TemplateArgumentList::CreateCopy(SemaRef.Context,
                                                           Innermost),
                                              /*InsertPos=*/nullptr);
} else if (isFriend && D->isThisDeclarationADefinition()) {
  // Do not connect the friend to the template unless it's actually a
  // definition. We don't want non-template functions to be marked as being
  // template instantiations.
  Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
} else if (!isFriend) {
  // If this is not a function template, and this is not a friend (that is,
  // this is a locally declared function), save the instantiation relationship
  // for the purposes of constraint instantiation.
  Function->setInstantiatedFromDecl(D);
}

if (isFriend) {
  Function->setObjectOfFriendDecl();
  if (FunctionTemplateDecl *FT = Function->getDescribedFunctionTemplate())
    FT->setObjectOfFriendDecl();
}

if (InitFunctionInstantiation(Function, D))
  Function->setInvalidDecl();

bool IsExplicitSpecialization = false;

LookupResult Previous(
    SemaRef, Function->getDeclName(), SourceLocation(),
    D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
                           : Sema::LookupOrdinaryName,
    D->isLocalExternDecl() ? Sema::ForExternalRedeclaration
                           : SemaRef.forRedeclarationInCurContext());

if (DependentFunctionTemplateSpecializationInfo *Info
      = D->getDependentSpecializationInfo()) {
  assert(isFriend && "non-friend has dependent specialization info?")(static_cast <bool> (isFriend && "non-friend has dependent specialization info?"
) ? void (0) : __assert_fail ("isFriend && \"non-friend has dependent specialization info?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2239, __extension__
 __PRETTY_FUNCTION__));

  // Instantiate the explicit template arguments.
  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                        Info->getRAngleLoc());
  if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
                                     ExplicitArgs))
    return nullptr;

  // Map the candidate templates to their instantiations.
  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
    Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                              Info->getTemplate(I),
                                              TemplateArgs);
    if (!Temp) return nullptr;

    Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
  }

  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
                                                  &ExplicitArgs,
                                                  Previous))
    Function->setInvalidDecl();

  IsExplicitSpecialization = true;
} else if (const ASTTemplateArgumentListInfo *Info =
               D->getTemplateSpecializationArgsAsWritten()) {
  // The name of this function was written as a template-id.
  SemaRef.LookupQualifiedName(Previous, DC);

  // Instantiate the explicit template arguments.
  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                        Info->getRAngleLoc());
  if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
                                     ExplicitArgs))
    return nullptr;

  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
                                                  &ExplicitArgs,
                                                  Previous))
    Function->setInvalidDecl();

  IsExplicitSpecialization = true;
} else if (TemplateParams || !FunctionTemplate) {
  // Look only into the namespace where the friend would be declared to
  // find a previous declaration. This is the innermost enclosing namespace,
  // as described in ActOnFriendFunctionDecl.
  SemaRef.LookupQualifiedName(Previous, DC->getRedeclContext());

  // In C++, the previous declaration we find might be a tag type
  // (class or enum). In this case, the new declaration will hide the
  // tag type. Note that this does not apply if we're declaring a
  // typedef (C++ [dcl.typedef]p4).
  if (Previous.isSingleTagDecl())
    Previous.clear();

  // Filter out previous declarations that don't match the scope. The only
  // effect this has is to remove declarations found in inline namespaces
  // for friend declarations with unqualified names.
  if (isFriend && !QualifierLoc) {
    SemaRef.FilterLookupForScope(Previous, DC, /*Scope=*/ nullptr,
                                 /*ConsiderLinkage=*/ true,
                                 QualifierLoc.hasQualifier());
  }
}

// Per [temp.inst], default arguments in function declarations at local scope
// are instantiated along with the enclosing declaration. For example:
//
//   template<typename T>
//   void ft() {
//     void f(int = []{ return T::value; }());
//   }
//   template void ft<int>(); // error: type 'int' cannot be used prior
//                                      to '::' because it has no members
//
// The error is issued during instantiation of ft<int>() because substitution
// into the default argument fails; the default argument is instantiated even
// though it is never used.
if (Function->isLocalExternDecl()) {
  for (ParmVarDecl *PVD : Function->parameters()) {
    if (!PVD->hasDefaultArg())
      continue;
    if (SemaRef.SubstDefaultArgument(D->getInnerLocStart(), PVD, TemplateArgs)) {
      // If substitution fails, the default argument is set to a
      // RecoveryExpr that wraps the uninstantiated default argument so
      // that downstream diagnostics are omitted.
      Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
      ExprResult ErrorResult = SemaRef.CreateRecoveryExpr(
          UninstExpr->getBeginLoc(), UninstExpr->getEndLoc(),
          { UninstExpr }, UninstExpr->getType());
      if (ErrorResult.isUsable())
        PVD->setDefaultArg(ErrorResult.get());
    }
  }
}

SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
                                 IsExplicitSpecialization,
                                 Function->isThisDeclarationADefinition());

// Check the template parameter list against the previous declaration. The
// goal here is to pick up default arguments added since the friend was
// declared; we know the template parameter lists match, since otherwise
// we would not have picked this template as the previous declaration.
if (isFriend && TemplateParams && FunctionTemplate->getPreviousDecl()) {
  SemaRef.CheckTemplateParameterList(
      TemplateParams,
      FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
      Function->isThisDeclarationADefinition()
          ? Sema::TPC_FriendFunctionTemplateDefinition
          : Sema::TPC_FriendFunctionTemplate);
}

// If we're introducing a friend definition after the first use, trigger
// instantiation.
// FIXME: If this is a friend function template definition, we should check
// to see if any specializations have been used.
if (isFriend && D->isThisDeclarationADefinition() && Function->isUsed(false)) {
  if (MemberSpecializationInfo *MSInfo =
          Function->getMemberSpecializationInfo()) {
    if (MSInfo->getPointOfInstantiation().isInvalid()) {
      SourceLocation Loc = D->getLocation(); // FIXME
      MSInfo->setPointOfInstantiation(Loc);
      SemaRef.PendingLocalImplicitInstantiations.push_back(
          std::make_pair(Function, Loc));
    }
  }
}

if (D->isExplicitlyDefaulted()) {
  if (SubstDefaultedFunction(Function, D))
    return nullptr;
}
if (D->isDeleted())
  SemaRef.SetDeclDeleted(Function, D->getLocation());

NamedDecl *PrincipalDecl =
    (TemplateParams ? cast<NamedDecl>(FunctionTemplate) : Function);

// If this declaration lives in a different context from its lexical context,
// add it to the corresponding lookup table.
if (isFriend ||
    (Function->isLocalExternDecl() && !Function->getPreviousDecl()))
  DC->makeDeclVisibleInContext(PrincipalDecl);

if (Function->isOverloadedOperator() && !DC->isRecord() &&
    PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
  PrincipalDecl->setNonMemberOperator();

return Function;
2390}

2392Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
  CXXMethodDecl *D, TemplateParameterList *TemplateParams,
  std::optional<const ASTTemplateArgumentListInfo *>
      ClassScopeSpecializationArgs,
  RewriteKind FunctionRewriteKind) {
FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
if (FunctionTemplate && !TemplateParams) {
  // We are creating a function template specialization from a function
  // template. Check whether there is already a function template
  // specialization for this particular set of template arguments.
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();

  void *InsertPos = nullptr;
  FunctionDecl *SpecFunc
    = FunctionTemplate->findSpecialization(Innermost, InsertPos);

  // If we already have a function template specialization, return it.
  if (SpecFunc)
    return SpecFunc;
}

bool isFriend;
if (FunctionTemplate)
  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
else
  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);

bool MergeWithParentScope = (TemplateParams != nullptr) ||
  !(isa<Decl>(Owner) &&
    cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);

// Instantiate enclosing template arguments for friends.
SmallVector<TemplateParameterList *, 4> TempParamLists;
unsigned NumTempParamLists = 0;
if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
  TempParamLists.resize(NumTempParamLists);
  for (unsigned I = 0; I != NumTempParamLists; ++I) {
    TemplateParameterList *TempParams = D->getTemplateParameterList(I);
    TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
    if (!InstParams)
      return nullptr;
    TempParamLists[I] = InstParams;
  }
}

ExplicitSpecifier InstantiatedExplicitSpecifier =
    instantiateExplicitSpecifier(SemaRef, TemplateArgs,
                                 ExplicitSpecifier::getFromDecl(D), D);
if (InstantiatedExplicitSpecifier.isInvalid())
  return nullptr;

// Implicit destructors/constructors created for local classes in
// DeclareImplicit* (see SemaDeclCXX.cpp) might not have an associated TSI.
// Unfortunately there isn't enough context in those functions to
// conditionally populate the TSI without breaking non-template related use
// cases. Populate TSIs prior to calling SubstFunctionType to make sure we get
// a proper transformation.
if (cast<CXXRecordDecl>(D->getParent())->isLambda() &&
    !D->getTypeSourceInfo() &&
    isa<CXXConstructorDecl, CXXDestructorDecl>(D)) {
  TypeSourceInfo *TSI =
      SemaRef.Context.getTrivialTypeSourceInfo(D->getType());
  D->setTypeSourceInfo(TSI);
}

SmallVector<ParmVarDecl *, 4> Params;
TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
if (!TInfo)
  return nullptr;
QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);

if (TemplateParams && TemplateParams->size()) {
  auto *LastParam =
      dyn_cast<TemplateTypeParmDecl>(TemplateParams->asArray().back());
  if (LastParam && LastParam->isImplicit() &&
      LastParam->hasTypeConstraint()) {
    // In abbreviated templates, the type-constraints of invented template
    // type parameters are instantiated with the function type, invalidating
    // the TemplateParameterList which relied on the template type parameter
    // not having a type constraint. Recreate the TemplateParameterList with
    // the updated parameter list.
    TemplateParams = TemplateParameterList::Create(
        SemaRef.Context, TemplateParams->getTemplateLoc(),
        TemplateParams->getLAngleLoc(), TemplateParams->asArray(),
        TemplateParams->getRAngleLoc(), TemplateParams->getRequiresClause());
  }
}

NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                               TemplateArgs);
  if (!QualifierLoc)
    return nullptr;
}

DeclContext *DC = Owner;
if (isFriend) {
  if (QualifierLoc) {
    CXXScopeSpec SS;
    SS.Adopt(QualifierLoc);
    DC = SemaRef.computeDeclContext(SS);

    if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
      return nullptr;
  } else {
    DC = SemaRef.FindInstantiatedContext(D->getLocation(),
                                         D->getDeclContext(),
                                         TemplateArgs);
  }
  if (!DC) return nullptr;
}

CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
Expr *TrailingRequiresClause = D->getTrailingRequiresClause();

DeclarationNameInfo NameInfo
  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);

if (FunctionRewriteKind != RewriteKind::None)
  adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);

// Build the instantiated method declaration.
CXXMethodDecl *Method = nullptr;

SourceLocation StartLoc = D->getInnerLocStart();
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
  Method = CXXConstructorDecl::Create(
      SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
      InstantiatedExplicitSpecifier, Constructor->UsesFPIntrin(),
      Constructor->isInlineSpecified(), false,
      Constructor->getConstexprKind(), InheritedConstructor(),
      TrailingRequiresClause);
  Method->setRangeEnd(Constructor->getEndLoc());
  if (Constructor->isDefaultConstructor() ||
      Constructor->isCopyOrMoveConstructor())
    Method->setIneligibleOrNotSelected(true);
} else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
  Method = CXXDestructorDecl::Create(
      SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
      Destructor->UsesFPIntrin(), Destructor->isInlineSpecified(), false,
      Destructor->getConstexprKind(), TrailingRequiresClause);
  Method->setIneligibleOrNotSelected(true);
  Method->setRangeEnd(Destructor->getEndLoc());
  Method->setDeclName(SemaRef.Context.DeclarationNames.getCXXDestructorName(
      SemaRef.Context.getCanonicalType(
          SemaRef.Context.getTypeDeclType(Record))));
} else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
  Method = CXXConversionDecl::Create(
      SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
      Conversion->UsesFPIntrin(), Conversion->isInlineSpecified(),
      InstantiatedExplicitSpecifier, Conversion->getConstexprKind(),
      Conversion->getEndLoc(), TrailingRequiresClause);
} else {
  StorageClass SC = D->isStatic() ? SC_Static : SC_None;
  Method = CXXMethodDecl::Create(
      SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo, SC,
      D->UsesFPIntrin(), D->isInlineSpecified(), D->getConstexprKind(),
      D->getEndLoc(), TrailingRequiresClause);
  if (D->isMoveAssignmentOperator() || D->isCopyAssignmentOperator())
    Method->setIneligibleOrNotSelected(true);
}

if (D->isInlined())
  Method->setImplicitlyInline();

if (QualifierLoc)
  Method->setQualifierInfo(QualifierLoc);

if (TemplateParams) {
  // Our resulting instantiation is actually a function template, since we
  // are substituting only the outer template parameters. For example, given
  //
  //   template<typename T>
  //   struct X {
  //     template<typename U> void f(T, U);
  //   };
  //
  //   X<int> x;
  //
  // We are instantiating the member template "f" within X<int>, which means
  // substituting int for T, but leaving "f" as a member function template.
  // Build the function template itself.
  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
                                                  Method->getLocation(),
                                                  Method->getDeclName(),
                                                  TemplateParams, Method);
  if (isFriend) {
    FunctionTemplate->setLexicalDeclContext(Owner);
    FunctionTemplate->setObjectOfFriendDecl();
  } else if (D->isOutOfLine())
    FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
  Method->setDescribedFunctionTemplate(FunctionTemplate);
} else if (FunctionTemplate) {
  // Record this function template specialization.
  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
  Method->setFunctionTemplateSpecialization(FunctionTemplate,
                       TemplateArgumentList::CreateCopy(SemaRef.Context,
                                                        Innermost),
                                            /*InsertPos=*/nullptr);
} else if (!isFriend) {
  // Record that this is an instantiation of a member function.
  Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
}

// If we are instantiating a member function defined
// out-of-line, the instantiation will have the same lexical
// context (which will be a namespace scope) as the template.
if (isFriend) {
  if (NumTempParamLists)
    Method->setTemplateParameterListsInfo(
        SemaRef.Context,
        llvm::ArrayRef(TempParamLists.data(), NumTempParamLists));

  Method->setLexicalDeclContext(Owner);
  Method->setObjectOfFriendDecl();
} else if (D->isOutOfLine())
  Method->setLexicalDeclContext(D->getLexicalDeclContext());

// Attach the parameters
for (unsigned P = 0; P < Params.size(); ++P)
  Params[P]->setOwningFunction(Method);
Method->setParams(Params);

if (InitMethodInstantiation(Method, D))
  Method->setInvalidDecl();

LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
                      Sema::ForExternalRedeclaration);

bool IsExplicitSpecialization = false;

// If the name of this function was written as a template-id, instantiate
// the explicit template arguments.
if (DependentFunctionTemplateSpecializationInfo *Info
      = D->getDependentSpecializationInfo()) {
  assert(isFriend && "non-friend has dependent specialization info?")(static_cast <bool> (isFriend && "non-friend has dependent specialization info?"
) ? void (0) : __assert_fail ("isFriend && \"non-friend has dependent specialization info?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2629, __extension__
 __PRETTY_FUNCTION__));

  // Instantiate the explicit template arguments.
  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                        Info->getRAngleLoc());
  if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
                                     ExplicitArgs))
    return nullptr;

  // Map the candidate templates to their instantiations.
  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
    Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
                                              Info->getTemplate(I),
                                              TemplateArgs);
    if (!Temp) return nullptr;

    Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
  }

  if (SemaRef.CheckFunctionTemplateSpecialization(Method,
                                                  &ExplicitArgs,
                                                  Previous))
    Method->setInvalidDecl();

  IsExplicitSpecialization = true;
} else if (const ASTTemplateArgumentListInfo *Info =
               ClassScopeSpecializationArgs.value_or(
                   D->getTemplateSpecializationArgsAsWritten())) {
  SemaRef.LookupQualifiedName(Previous, DC);

  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                        Info->getRAngleLoc());
  if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
                                     ExplicitArgs))
    return nullptr;

  if (SemaRef.CheckFunctionTemplateSpecialization(Method,
                                                  &ExplicitArgs,
                                                  Previous))
    Method->setInvalidDecl();

  IsExplicitSpecialization = true;
} else if (ClassScopeSpecializationArgs) {
  // Class-scope explicit specialization written without explicit template
  // arguments.
  SemaRef.LookupQualifiedName(Previous, DC);
  if (SemaRef.CheckFunctionTemplateSpecialization(Method, nullptr, Previous))
    Method->setInvalidDecl();

  IsExplicitSpecialization = true;
} else if (!FunctionTemplate || TemplateParams || isFriend) {
  SemaRef.LookupQualifiedName(Previous, Record);

  // In C++, the previous declaration we find might be a tag type
  // (class or enum). In this case, the new declaration will hide the
  // tag type. Note that this does not apply if we're declaring a
  // typedef (C++ [dcl.typedef]p4).
  if (Previous.isSingleTagDecl())
    Previous.clear();
}

// Per [temp.inst], default arguments in member functions of local classes
// are instantiated along with the member function declaration. For example:
//
//   template<typename T>
//   void ft() {
//     struct lc {
//       int operator()(int p = []{ return T::value; }());
//     };
//   }
//   template void ft<int>(); // error: type 'int' cannot be used prior
//                                      to '::'because it has no members
//
// The error is issued during instantiation of ft<int>()::lc::operator()
// because substitution into the default argument fails; the default argument
// is instantiated even though it is never used.
if (D->isInLocalScopeForInstantiation()) {
  for (unsigned P = 0; P < Params.size(); ++P) {
    if (!Params[P]->hasDefaultArg())
      continue;
    if (SemaRef.SubstDefaultArgument(StartLoc, Params[P], TemplateArgs)) {
      // If substitution fails, the default argument is set to a
      // RecoveryExpr that wraps the uninstantiated default argument so
      // that downstream diagnostics are omitted.
      Expr *UninstExpr = Params[P]->getUninstantiatedDefaultArg();
      ExprResult ErrorResult = SemaRef.CreateRecoveryExpr(
          UninstExpr->getBeginLoc(), UninstExpr->getEndLoc(),
          { UninstExpr }, UninstExpr->getType());
      if (ErrorResult.isUsable())
        Params[P]->setDefaultArg(ErrorResult.get());
    }
  }
}

SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous,
                                 IsExplicitSpecialization,
                                 Method->isThisDeclarationADefinition());

if (D->isPure())
  SemaRef.CheckPureMethod(Method, SourceRange());

// Propagate access.  For a non-friend declaration, the access is
// whatever we're propagating from.  For a friend, it should be the
// previous declaration we just found.
if (isFriend && Method->getPreviousDecl())
  Method->setAccess(Method->getPreviousDecl()->getAccess());
else
  Method->setAccess(D->getAccess());
if (FunctionTemplate)
  FunctionTemplate->setAccess(Method->getAccess());

SemaRef.CheckOverrideControl(Method);

// If a function is defined as defaulted or deleted, mark it as such now.
if (D->isExplicitlyDefaulted()) {
  if (SubstDefaultedFunction(Method, D))
    return nullptr;
}
if (D->isDeletedAsWritten())
  SemaRef.SetDeclDeleted(Method, Method->getLocation());

// If this is an explicit specialization, mark the implicitly-instantiated
// template specialization as being an explicit specialization too.
// FIXME: Is this necessary?
if (IsExplicitSpecialization && !isFriend)
  SemaRef.CompleteMemberSpecialization(Method, Previous);

// If there's a function template, let our caller handle it.
if (FunctionTemplate) {
  // do nothing

// Don't hide a (potentially) valid declaration with an invalid one.
} else if (Method->isInvalidDecl() && !Previous.empty()) {
  // do nothing

// Otherwise, check access to friends and make them visible.
} else if (isFriend) {
  // We only need to re-check access for methods which we didn't
  // manage to match during parsing.
  if (!D->getPreviousDecl())
    SemaRef.CheckFriendAccess(Method);

  Record->makeDeclVisibleInContext(Method);

// Otherwise, add the declaration.  We don't need to do this for
// class-scope specializations because we'll have matched them with
// the appropriate template.
} else {
  Owner->addDecl(Method);
}

// PR17480: Honor the used attribute to instantiate member function
// definitions
if (Method->hasAttr<UsedAttr>()) {
  if (const auto *A = dyn_cast<CXXRecordDecl>(Owner)) {
    SourceLocation Loc;
    if (const MemberSpecializationInfo *MSInfo =
            A->getMemberSpecializationInfo())
      Loc = MSInfo->getPointOfInstantiation();
    else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A))
      Loc = Spec->getPointOfInstantiation();
    SemaRef.MarkFunctionReferenced(Loc, Method);
  }
}

return Method;
2795}

2797Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
return VisitCXXMethodDecl(D);
2799}

2801Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
return VisitCXXMethodDecl(D);
2803}

2805Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
return VisitCXXMethodDecl(D);
2807}

2809Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0,
                                std::nullopt,
                                /*ExpectParameterPack=*/false);
2813}

2815Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
                                                  TemplateTypeParmDecl *D) {
assert(D->getTypeForDecl()->isTemplateTypeParmType())(static_cast <bool> (D->getTypeForDecl()->isTemplateTypeParmType
()) ? void (0) : __assert_fail ("D->getTypeForDecl()->isTemplateTypeParmType()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2817, __extension__
 __PRETTY_FUNCTION__));

std::optional<unsigned> NumExpanded;

if (const TypeConstraint *TC = D->getTypeConstraint()) {
  if (D->isPackExpansion() && !D->isExpandedParameterPack()) {
    assert(TC->getTemplateArgsAsWritten() &&(static_cast <bool> (TC->getTemplateArgsAsWritten() &&
 "type parameter can only be an expansion when explicit arguments "
 "are specified") ? void (0) : __assert_fail ("TC->getTemplateArgsAsWritten() && \"type parameter can only be an expansion when explicit arguments \" \"are specified\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2825, __extension__
 __PRETTY_FUNCTION__))
           "type parameter can only be an expansion when explicit arguments "(static_cast <bool> (TC->getTemplateArgsAsWritten() &&
 "type parameter can only be an expansion when explicit arguments "
 "are specified") ? void (0) : __assert_fail ("TC->getTemplateArgsAsWritten() && \"type parameter can only be an expansion when explicit arguments \" \"are specified\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2825, __extension__
 __PRETTY_FUNCTION__))
           "are specified")(static_cast <bool> (TC->getTemplateArgsAsWritten() &&
 "type parameter can only be an expansion when explicit arguments "
 "are specified") ? void (0) : __assert_fail ("TC->getTemplateArgsAsWritten() && \"type parameter can only be an expansion when explicit arguments \" \"are specified\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 2825, __extension__
 __PRETTY_FUNCTION__));
    // The template type parameter pack's type is a pack expansion of types.
    // Determine whether we need to expand this parameter pack into separate
    // types.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    for (auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
      SemaRef.collectUnexpandedParameterPacks(ArgLoc, Unexpanded);

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    if (SemaRef.CheckParameterPacksForExpansion(
            cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
                ->getEllipsisLoc(),
            SourceRange(TC->getConceptNameLoc(),
                        TC->hasExplicitTemplateArgs() ?
                        TC->getTemplateArgsAsWritten()->getRAngleLoc() :
                        TC->getConceptNameInfo().getEndLoc()),
            Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpanded))
      return nullptr;
  }
}

TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
    SemaRef.Context, Owner, D->getBeginLoc(), D->getLocation(),
    D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
    D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack(),
    D->hasTypeConstraint(), NumExpanded);

Inst->setAccess(AS_public);
Inst->setImplicit(D->isImplicit());
if (auto *TC = D->getTypeConstraint()) {
  if (!D->isImplicit()) {
    // Invented template parameter type constraints will be instantiated
    // with the corresponding auto-typed parameter as it might reference
    // other parameters.
    if (SemaRef.SubstTypeConstraint(Inst, TC, TemplateArgs,
                                    EvaluateConstraints))
      return nullptr;
  }
}
if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
  TypeSourceInfo *InstantiatedDefaultArg =
      SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
                        D->getDefaultArgumentLoc(), D->getDeclName());
  if (InstantiatedDefaultArg)
    Inst->setDefaultArgument(InstantiatedDefaultArg);
}

// Introduce this template parameter's instantiation into the instantiation
// scope.
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);

return Inst;
2880}

2882Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
                                               NonTypeTemplateParmDecl *D) {
// Substitute into the type of the non-type template parameter.
TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
SmallVector<QualType, 4> ExpandedParameterPackTypes;
bool IsExpandedParameterPack = false;
TypeSourceInfo *DI;
QualType T;
bool Invalid = false;

if (D->isExpandedParameterPack()) {
  // The non-type template parameter pack is an already-expanded pack
  // expansion of types. Substitute into each of the expanded types.
  ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
  ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
    TypeSourceInfo *NewDI =
        SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
                          D->getLocation(), D->getDeclName());
    if (!NewDI)
      return nullptr;

    QualType NewT =
        SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
    if (NewT.isNull())
      return nullptr;

    ExpandedParameterPackTypesAsWritten.push_back(NewDI);
    ExpandedParameterPackTypes.push_back(NewT);
  }

  IsExpandedParameterPack = true;
  DI = D->getTypeSourceInfo();
  T = DI->getType();
} else if (D->isPackExpansion()) {
  // The non-type template parameter pack's type is a pack expansion of types.
  // Determine whether we need to expand this parameter pack into separate
  // types.
  PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
  TypeLoc Pattern = Expansion.getPatternLoc();
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  std::optional<unsigned> OrigNumExpansions =
      Expansion.getTypePtr()->getNumExpansions();
  std::optional<unsigned> NumExpansions = OrigNumExpansions;
  if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
                                              Pattern.getSourceRange(),
                                              Unexpanded,
                                              TemplateArgs,
                                              Expand, RetainExpansion,
                                              NumExpansions))
    return nullptr;

  if (Expand) {
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
      TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
                                                D->getLocation(),
                                                D->getDeclName());
      if (!NewDI)
        return nullptr;

      QualType NewT =
          SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
      if (NewT.isNull())
        return nullptr;

      ExpandedParameterPackTypesAsWritten.push_back(NewDI);
      ExpandedParameterPackTypes.push_back(NewT);
    }

    // Note that we have an expanded parameter pack. The "type" of this
    // expanded parameter pack is the original expansion type, but callers
    // will end up using the expanded parameter pack types for type-checking.
    IsExpandedParameterPack = true;
    DI = D->getTypeSourceInfo();
    T = DI->getType();
  } else {
    // We cannot fully expand the pack expansion now, so substitute into the
    // pattern and create a new pack expansion type.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
    TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
                                                   D->getLocation(),
                                                   D->getDeclName());
    if (!NewPattern)
      return nullptr;

    SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
    DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
                                    NumExpansions);
    if (!DI)
      return nullptr;

    T = DI->getType();
  }
} else {
  // Simple case: substitution into a parameter that is not a parameter pack.
  DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
                         D->getLocation(), D->getDeclName());
  if (!DI)
    return nullptr;

  // Check that this type is acceptable for a non-type template parameter.
  T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
  if (T.isNull()) {
    T = SemaRef.Context.IntTy;
    Invalid = true;
  }
}

NonTypeTemplateParmDecl *Param;
if (IsExpandedParameterPack)
  Param = NonTypeTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
      ExpandedParameterPackTypesAsWritten);
else
  Param = NonTypeTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);

if (AutoTypeLoc AutoLoc = DI->getTypeLoc().getContainedAutoTypeLoc())
  if (AutoLoc.isConstrained())
    // Note: We attach the uninstantiated constriant here, so that it can be
    // instantiated relative to the top level, like all our other constraints.
    if (SemaRef.AttachTypeConstraint(
            AutoLoc, Param, D,
            IsExpandedParameterPack
              ? DI->getTypeLoc().getAs<PackExpansionTypeLoc>()
                  .getEllipsisLoc()
              : SourceLocation()))
      Invalid = true;

Param->setAccess(AS_public);
Param->setImplicit(D->isImplicit());
if (Invalid)
  Param->setInvalidDecl();

if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
  EnterExpressionEvaluationContext ConstantEvaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
  if (!Value.isInvalid())
    Param->setDefaultArgument(Value.get());
}

// Introduce this template parameter's instantiation into the instantiation
// scope.
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
return Param;
3040}

3042static void collectUnexpandedParameterPacks(
  Sema &S,
  TemplateParameterList *Params,
  SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
for (const auto &P : *Params) {
  if (P->isTemplateParameterPack())
    continue;
  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
    S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
                                      Unexpanded);
  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
    collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
                                    Unexpanded);
}
3056}

3058Decl *
3059TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
                                                TemplateTemplateParmDecl *D) {
// Instantiate the template parameter list of the template template parameter.
TemplateParameterList *TempParams = D->getTemplateParameters();
TemplateParameterList *InstParams;
SmallVector<TemplateParameterList*, 8> ExpandedParams;

bool IsExpandedParameterPack = false;

if (D->isExpandedParameterPack()) {
  // The template template parameter pack is an already-expanded pack
  // expansion of template parameters. Substitute into each of the expanded
  // parameters.
  ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
       I != N; ++I) {
    LocalInstantiationScope Scope(SemaRef);
    TemplateParameterList *Expansion =
      SubstTemplateParams(D->getExpansionTemplateParameters(I));
    if (!Expansion)
      return nullptr;
    ExpandedParams.push_back(Expansion);
  }

  IsExpandedParameterPack = true;
  InstParams = TempParams;
} else if (D->isPackExpansion()) {
  // The template template parameter pack expands to a pack of template
  // template parameters. Determine whether we need to expand this parameter
  // pack into separate parameters.
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
                                  Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  std::optional<unsigned> NumExpansions;
  if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
                                              TempParams->getSourceRange(),
                                              Unexpanded,
                                              TemplateArgs,
                                              Expand, RetainExpansion,
                                              NumExpansions))
    return nullptr;

  if (Expand) {
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
      LocalInstantiationScope Scope(SemaRef);
      TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
      if (!Expansion)
        return nullptr;
      ExpandedParams.push_back(Expansion);
    }

    // Note that we have an expanded parameter pack. The "type" of this
    // expanded parameter pack is the original expansion type, but callers
    // will end up using the expanded parameter pack types for type-checking.
    IsExpandedParameterPack = true;
    InstParams = TempParams;
  } else {
    // We cannot fully expand the pack expansion now, so just substitute
    // into the pattern.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);

    LocalInstantiationScope Scope(SemaRef);
    InstParams = SubstTemplateParams(TempParams);
    if (!InstParams)
      return nullptr;
  }
} else {
  // Perform the actual substitution of template parameters within a new,
  // local instantiation scope.
  LocalInstantiationScope Scope(SemaRef);
  InstParams = SubstTemplateParams(TempParams);
  if (!InstParams)
    return nullptr;
}

// Build the template template parameter.
TemplateTemplateParmDecl *Param;
if (IsExpandedParameterPack)
  Param = TemplateTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
else
  Param = TemplateTemplateParmDecl::Create(
      SemaRef.Context, Owner, D->getLocation(),
      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
      D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
  NestedNameSpecifierLoc QualifierLoc =
      D->getDefaultArgument().getTemplateQualifierLoc();
  QualifierLoc =
      SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
  TemplateName TName = SemaRef.SubstTemplateName(
      QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
      D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
  if (!TName.isNull())
    Param->setDefaultArgument(
        SemaRef.Context,
        TemplateArgumentLoc(SemaRef.Context, TemplateArgument(TName),
                            D->getDefaultArgument().getTemplateQualifierLoc(),
                            D->getDefaultArgument().getTemplateNameLoc()));
}
Param->setAccess(AS_public);
Param->setImplicit(D->isImplicit());

// Introduce this template parameter's instantiation into the instantiation
// scope.
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);

return Param;
3175}

3177Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
// Using directives are never dependent (and never contain any types or
// expressions), so they require no explicit instantiation work.

UsingDirectiveDecl *Inst
  = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                               D->getNamespaceKeyLocation(),
                               D->getQualifierLoc(),
                               D->getIdentLocation(),
                               D->getNominatedNamespace(),
                               D->getCommonAncestor());

// Add the using directive to its declaration context
// only if this is not a function or method.
if (!Owner->isFunctionOrMethod())
  Owner->addDecl(Inst);

return Inst;
3195}

3197Decl *TemplateDeclInstantiator::VisitBaseUsingDecls(BaseUsingDecl *D,
                                                  BaseUsingDecl *Inst,
                                                  LookupResult *Lookup) {

bool isFunctionScope = Owner->isFunctionOrMethod();

for (auto *Shadow : D->shadows()) {
  // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
  // reconstruct it in the case where it matters. Hm, can we extract it from
  // the DeclSpec when parsing and save it in the UsingDecl itself?
  NamedDecl *OldTarget = Shadow->getTargetDecl();
  if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
    if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
      OldTarget = BaseShadow;

  NamedDecl *InstTarget = nullptr;
  if (auto *EmptyD =
          dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
    InstTarget = UnresolvedUsingIfExistsDecl::Create(
        SemaRef.Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
  } else {
    InstTarget = cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
        Shadow->getLocation(), OldTarget, TemplateArgs));
  }
  if (!InstTarget)
    return nullptr;

  UsingShadowDecl *PrevDecl = nullptr;
  if (Lookup &&
      SemaRef.CheckUsingShadowDecl(Inst, InstTarget, *Lookup, PrevDecl))
    continue;

  if (UsingShadowDecl *OldPrev = getPreviousDeclForInstantiation(Shadow))
    PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
        Shadow->getLocation(), OldPrev, TemplateArgs));

  UsingShadowDecl *InstShadow = SemaRef.BuildUsingShadowDecl(
      /*Scope*/ nullptr, Inst, InstTarget, PrevDecl);
  SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);

  if (isFunctionScope)
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
}

return Inst;
3242}

3244Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {

// The nested name specifier may be dependent, for example
//     template <typename T> struct t {
//       struct s1 { T f1(); };
//       struct s2 : s1 { using s1::f1; };
//     };
//     template struct t<int>;
// Here, in using s1::f1, s1 refers to t<T>::s1;
// we need to substitute for t<int>::s1.
NestedNameSpecifierLoc QualifierLoc
  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
                                        TemplateArgs);
if (!QualifierLoc)
  return nullptr;

// For an inheriting constructor declaration, the name of the using
// declaration is the name of a constructor in this class, not in the
// base class.
DeclarationNameInfo NameInfo = D->getNameInfo();
if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
  if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
    NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
        SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));

// We only need to do redeclaration lookups if we're in a class scope (in
// fact, it's not really even possible in non-class scopes).
bool CheckRedeclaration = Owner->isRecord();
LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
                  Sema::ForVisibleRedeclaration);

UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
                                     D->getUsingLoc(),
                                     QualifierLoc,
                                     NameInfo,
                                     D->hasTypename());

CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
if (CheckRedeclaration) {
  Prev.setHideTags(false);
  SemaRef.LookupQualifiedName(Prev, Owner);

  // Check for invalid redeclarations.
  if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
                                          D->hasTypename(), SS,
                                          D->getLocation(), Prev))
    NewUD->setInvalidDecl();
}

if (!NewUD->isInvalidDecl() &&
    SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(), SS,
                                    NameInfo, D->getLocation(), nullptr, D))
  NewUD->setInvalidDecl();

SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
NewUD->setAccess(D->getAccess());
Owner->addDecl(NewUD);

// Don't process the shadow decls for an invalid decl.
if (NewUD->isInvalidDecl())
  return NewUD;

// If the using scope was dependent, or we had dependent bases, we need to
// recheck the inheritance
if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
  SemaRef.CheckInheritingConstructorUsingDecl(NewUD);

return VisitBaseUsingDecls(D, NewUD, CheckRedeclaration ? &Prev : nullptr);
3313}

3315Decl *TemplateDeclInstantiator::VisitUsingEnumDecl(UsingEnumDecl *D) {
// Cannot be a dependent type, but still could be an instantiation
EnumDecl *EnumD = cast_or_null<EnumDecl>(SemaRef.FindInstantiatedDecl(
    D->getLocation(), D->getEnumDecl(), TemplateArgs));

if (SemaRef.RequireCompleteEnumDecl(EnumD, EnumD->getLocation()))
  return nullptr;

TypeSourceInfo *TSI = SemaRef.SubstType(D->getEnumType(), TemplateArgs,
                                        D->getLocation(), D->getDeclName());
UsingEnumDecl *NewUD =
    UsingEnumDecl::Create(SemaRef.Context, Owner, D->getUsingLoc(),
                          D->getEnumLoc(), D->getLocation(), TSI);

SemaRef.Context.setInstantiatedFromUsingEnumDecl(NewUD, D);
NewUD->setAccess(D->getAccess());
Owner->addDecl(NewUD);

// Don't process the shadow decls for an invalid decl.
if (NewUD->isInvalidDecl())
  return NewUD;

// We don't have to recheck for duplication of the UsingEnumDecl itself, as it
// cannot be dependent, and will therefore have been checked during template
// definition.

return VisitBaseUsingDecls(D, NewUD, nullptr);
3342}

3344Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
// Ignore these;  we handle them in bulk when processing the UsingDecl.
return nullptr;
3347}

3349Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
  ConstructorUsingShadowDecl *D) {
// Ignore these;  we handle them in bulk when processing the UsingDecl.
return nullptr;
3353}

3355template <typename T>
3356Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
  T *D, bool InstantiatingPackElement) {
// If this is a pack expansion, expand it now.
if (D->isPackExpansion() && !InstantiatingPackElement) {
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
  SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  std::optional<unsigned> NumExpansions;
  if (SemaRef.CheckParameterPacksForExpansion(
        D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
          Expand, RetainExpansion, NumExpansions))
    return nullptr;

  // This declaration cannot appear within a function template signature,
  // so we can't have a partial argument list for a parameter pack.
  assert(!RetainExpansion &&(static_cast <bool> (!RetainExpansion && "should never need to retain an expansion for UsingPackDecl"
) ? void (0) : __assert_fail ("!RetainExpansion && \"should never need to retain an expansion for UsingPackDecl\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3377, __extension__
 __PRETTY_FUNCTION__))
         "should never need to retain an expansion for UsingPackDecl")(static_cast <bool> (!RetainExpansion && "should never need to retain an expansion for UsingPackDecl"
) ? void (0) : __assert_fail ("!RetainExpansion && \"should never need to retain an expansion for UsingPackDecl\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3377, __extension__
 __PRETTY_FUNCTION__));

  if (!Expand) {
    // We cannot fully expand the pack expansion now, so substitute into the
    // pattern and create a new pack expansion.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
    return instantiateUnresolvedUsingDecl(D, true);
  }

  // Within a function, we don't have any normal way to check for conflicts
  // between shadow declarations from different using declarations in the
  // same pack expansion, but this is always ill-formed because all expansions
  // must produce (conflicting) enumerators.
  //
  // Sadly we can't just reject this in the template definition because it
  // could be valid if the pack is empty or has exactly one expansion.
  if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
    SemaRef.Diag(D->getEllipsisLoc(),
                 diag::err_using_decl_redeclaration_expansion);
    return nullptr;
  }

  // Instantiate the slices of this pack and build a UsingPackDecl.
  SmallVector<NamedDecl*, 8> Expansions;
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
    Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
    if (!Slice)
      return nullptr;
    // Note that we can still get unresolved using declarations here, if we
    // had arguments for all packs but the pattern also contained other
    // template arguments (this only happens during partial substitution, eg
    // into the body of a generic lambda in a function template).
    Expansions.push_back(cast<NamedDecl>(Slice));
  }

  auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
  if (isDeclWithinFunction(D))
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
  return NewD;
}

UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();

NestedNameSpecifierLoc QualifierLoc
  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
                                        TemplateArgs);
if (!QualifierLoc)
  return nullptr;

CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

DeclarationNameInfo NameInfo
  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);

// Produce a pack expansion only if we're not instantiating a particular
// slice of a pack expansion.
bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
                          SemaRef.ArgumentPackSubstitutionIndex != -1;
SourceLocation EllipsisLoc =
    InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();

bool IsUsingIfExists = D->template hasAttr<UsingIfExistsAttr>();
NamedDecl *UD = SemaRef.BuildUsingDeclaration(
    /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
    /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
    ParsedAttributesView(),
    /*IsInstantiation*/ true, IsUsingIfExists);
if (UD) {
  SemaRef.InstantiateAttrs(TemplateArgs, D, UD);
  SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
}

return UD;
3453}

3455Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
  UnresolvedUsingTypenameDecl *D) {
return instantiateUnresolvedUsingDecl(D);
3458}

3460Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
  UnresolvedUsingValueDecl *D) {
return instantiateUnresolvedUsingDecl(D);
3463}

3465Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
  UnresolvedUsingIfExistsDecl *D) {
llvm_unreachable("referring to unresolved decl out of UsingShadowDecl")::llvm::llvm_unreachable_internal("referring to unresolved decl out of UsingShadowDecl"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3467);
3468}

3470Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
SmallVector<NamedDecl*, 8> Expansions;
for (auto *UD : D->expansions()) {
  if (NamedDecl *NewUD =
          SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
    Expansions.push_back(NewUD);
  else
    return nullptr;
}

auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
if (isDeclWithinFunction(D))
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
return NewD;
3484}

3486Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
  ClassScopeFunctionSpecializationDecl *Decl) {
CXXMethodDecl *OldFD = Decl->getSpecialization();
return cast_or_null<CXXMethodDecl>(
    VisitCXXMethodDecl(OldFD, nullptr, Decl->getTemplateArgsAsWritten()));
3491}

3493Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
                                   OMPThreadPrivateDecl *D) {
SmallVector<Expr *, 5> Vars;
for (auto *I : D->varlists()) {
  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
  assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr")(static_cast <bool> (isa<DeclRefExpr>(Var) &&
 "threadprivate arg is not a DeclRefExpr") ? void (0) : __assert_fail
 ("isa<DeclRefExpr>(Var) && \"threadprivate arg is not a DeclRefExpr\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3498, __extension__
 __PRETTY_FUNCTION__));
  Vars.push_back(Var);
}

OMPThreadPrivateDecl *TD =
  SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);

TD->setAccess(AS_public);
Owner->addDecl(TD);

return TD;
3509}

3511Decl *TemplateDeclInstantiator::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
SmallVector<Expr *, 5> Vars;
for (auto *I : D->varlists()) {
  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
  assert(isa<DeclRefExpr>(Var) && "allocate arg is not a DeclRefExpr")(static_cast <bool> (isa<DeclRefExpr>(Var) &&
 "allocate arg is not a DeclRefExpr") ? void (0) : __assert_fail
 ("isa<DeclRefExpr>(Var) && \"allocate arg is not a DeclRefExpr\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3515, __extension__
 __PRETTY_FUNCTION__));
  Vars.push_back(Var);
}
SmallVector<OMPClause *, 4> Clauses;
// Copy map clauses from the original mapper.
for (OMPClause *C : D->clauselists()) {
  OMPClause *IC = nullptr;
  if (auto *AC = dyn_cast<OMPAllocatorClause>(C)) {
    ExprResult NewE = SemaRef.SubstExpr(AC->getAllocator(), TemplateArgs);
    if (!NewE.isUsable())
      continue;
    IC = SemaRef.ActOnOpenMPAllocatorClause(
        NewE.get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
  } else if (auto *AC = dyn_cast<OMPAlignClause>(C)) {
    ExprResult NewE = SemaRef.SubstExpr(AC->getAlignment(), TemplateArgs);
    if (!NewE.isUsable())
      continue;
    IC = SemaRef.ActOnOpenMPAlignClause(NewE.get(), AC->getBeginLoc(),
                                        AC->getLParenLoc(), AC->getEndLoc());
    // If align clause value ends up being invalid, this can end up null.
    if (!IC)
      continue;
  }
  Clauses.push_back(IC);
}

Sema::DeclGroupPtrTy Res = SemaRef.ActOnOpenMPAllocateDirective(
    D->getLocation(), Vars, Clauses, Owner);
if (Res.get().isNull())
  return nullptr;
return Res.get().getSingleDecl();
3546}

3548Decl *TemplateDeclInstantiator::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
llvm_unreachable(::llvm::llvm_unreachable_internal("Requires directive cannot be instantiated within a dependent context"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3550)
    "Requires directive cannot be instantiated within a dependent context")::llvm::llvm_unreachable_internal("Requires directive cannot be instantiated within a dependent context"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3550);
3551}

3553Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
  OMPDeclareReductionDecl *D) {
// Instantiate type and check if it is allowed.
const bool RequiresInstantiation =
    D->getType()->isDependentType() ||
    D->getType()->isInstantiationDependentType() ||
    D->getType()->containsUnexpandedParameterPack();
QualType SubstReductionType;
if (RequiresInstantiation) {
  SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
      D->getLocation(),
      ParsedType::make(SemaRef.SubstType(
          D->getType(), TemplateArgs, D->getLocation(), DeclarationName())));
} else {
  SubstReductionType = D->getType();
}
if (SubstReductionType.isNull())
  return nullptr;
Expr *Combiner = D->getCombiner();
Expr *Init = D->getInitializer();
bool IsCorrect = true;
// Create instantiated copy.
std::pair<QualType, SourceLocation> ReductionTypes[] = {
    std::make_pair(SubstReductionType, D->getLocation())};
auto *PrevDeclInScope = D->getPrevDeclInScope();
if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
  PrevDeclInScope = cast<OMPDeclareReductionDecl>(
      SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
          ->get<Decl *>());
}
auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
    /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
    PrevDeclInScope);
auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
Expr *SubstCombiner = nullptr;
Expr *SubstInitializer = nullptr;
// Combiners instantiation sequence.
if (Combiner) {
  SemaRef.ActOnOpenMPDeclareReductionCombinerStart(
      /*S=*/nullptr, NewDRD);
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(
      cast<DeclRefExpr>(D->getCombinerIn())->getDecl(),
      cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(
      cast<DeclRefExpr>(D->getCombinerOut())->getDecl(),
      cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
  auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
  Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
                                   ThisContext);
  SubstCombiner = SemaRef.SubstExpr(Combiner, TemplateArgs).get();
  SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
}
// Initializers instantiation sequence.
if (Init) {
  VarDecl *OmpPrivParm = SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
      /*S=*/nullptr, NewDRD);
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(
      cast<DeclRefExpr>(D->getInitOrig())->getDecl(),
      cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
  SemaRef.CurrentInstantiationScope->InstantiatedLocal(
      cast<DeclRefExpr>(D->getInitPriv())->getDecl(),
      cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
  if (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit) {
    SubstInitializer = SemaRef.SubstExpr(Init, TemplateArgs).get();
  } else {
    auto *OldPrivParm =
        cast<VarDecl>(cast<DeclRefExpr>(D->getInitPriv())->getDecl());
    IsCorrect = IsCorrect && OldPrivParm->hasInit();
    if (IsCorrect)
      SemaRef.InstantiateVariableInitializer(OmpPrivParm, OldPrivParm,
                                             TemplateArgs);
  }
  SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(NewDRD, SubstInitializer,
                                                    OmpPrivParm);
}
IsCorrect = IsCorrect && SubstCombiner &&
            (!Init ||
             (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit &&
              SubstInitializer) ||
             (D->getInitializerKind() != OMPDeclareReductionDecl::CallInit &&
              !SubstInitializer));

(void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(
    /*S=*/nullptr, DRD, IsCorrect && !D->isInvalidDecl());

return NewDRD;
3640}

3642Decl *
3643TemplateDeclInstantiator::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
// Instantiate type and check if it is allowed.
const bool RequiresInstantiation =
    D->getType()->isDependentType() ||
    D->getType()->isInstantiationDependentType() ||
    D->getType()->containsUnexpandedParameterPack();
QualType SubstMapperTy;
DeclarationName VN = D->getVarName();
if (RequiresInstantiation) {
  SubstMapperTy = SemaRef.ActOnOpenMPDeclareMapperType(
      D->getLocation(),
      ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
                                         D->getLocation(), VN)));
} else {
  SubstMapperTy = D->getType();
}
if (SubstMapperTy.isNull())
  return nullptr;
// Create an instantiated copy of mapper.
auto *PrevDeclInScope = D->getPrevDeclInScope();
if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
  PrevDeclInScope = cast<OMPDeclareMapperDecl>(
      SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
          ->get<Decl *>());
}
bool IsCorrect = true;
SmallVector<OMPClause *, 6> Clauses;
// Instantiate the mapper variable.
DeclarationNameInfo DirName;
SemaRef.StartOpenMPDSABlock(llvm::omp::OMPD_declare_mapper, DirName,
                            /*S=*/nullptr,
                            (*D->clauselist_begin())->getBeginLoc());
ExprResult MapperVarRef = SemaRef.ActOnOpenMPDeclareMapperDirectiveVarDecl(
    /*S=*/nullptr, SubstMapperTy, D->getLocation(), VN);
SemaRef.CurrentInstantiationScope->InstantiatedLocal(
    cast<DeclRefExpr>(D->getMapperVarRef())->getDecl(),
    cast<DeclRefExpr>(MapperVarRef.get())->getDecl());
auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
                                 ThisContext);
// Instantiate map clauses.
for (OMPClause *C : D->clauselists()) {
  auto *OldC = cast<OMPMapClause>(C);
  SmallVector<Expr *, 4> NewVars;
  for (Expr *OE : OldC->varlists()) {
    Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs).get();
    if (!NE) {
      IsCorrect = false;
      break;
    }
    NewVars.push_back(NE);
  }
  if (!IsCorrect)
    break;
  NestedNameSpecifierLoc NewQualifierLoc =
      SemaRef.SubstNestedNameSpecifierLoc(OldC->getMapperQualifierLoc(),
                                          TemplateArgs);
  CXXScopeSpec SS;
  SS.Adopt(NewQualifierLoc);
  DeclarationNameInfo NewNameInfo =
      SemaRef.SubstDeclarationNameInfo(OldC->getMapperIdInfo(), TemplateArgs);
  OMPVarListLocTy Locs(OldC->getBeginLoc(), OldC->getLParenLoc(),
                       OldC->getEndLoc());
  OMPClause *NewC = SemaRef.ActOnOpenMPMapClause(
      OldC->getIteratorModifier(), OldC->getMapTypeModifiers(),
      OldC->getMapTypeModifiersLoc(), SS, NewNameInfo, OldC->getMapType(),
      OldC->isImplicitMapType(), OldC->getMapLoc(), OldC->getColonLoc(),
      NewVars, Locs);
  Clauses.push_back(NewC);
}
SemaRef.EndOpenMPDSABlock(nullptr);
if (!IsCorrect)
  return nullptr;
Sema::DeclGroupPtrTy DG = SemaRef.ActOnOpenMPDeclareMapperDirective(
    /*S=*/nullptr, Owner, D->getDeclName(), SubstMapperTy, D->getLocation(),
    VN, D->getAccess(), MapperVarRef.get(), Clauses, PrevDeclInScope);
Decl *NewDMD = DG.get().getSingleDecl();
SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDMD);
return NewDMD;
3722}

3724Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
  OMPCapturedExprDecl * /*D*/) {
llvm_unreachable("Should not be met in templates")::llvm::llvm_unreachable_internal("Should not be met in templates"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3726);
3727}

3729Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
return VisitFunctionDecl(D, nullptr);
3731}

3733Decl *
3734TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
Decl *Inst = VisitFunctionDecl(D, nullptr);
if (Inst && !D->getDescribedFunctionTemplate())
  Owner->addDecl(Inst);
return Inst;
3739}

3741Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
return VisitCXXMethodDecl(D, nullptr);
3743}

3745Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
llvm_unreachable("There are only CXXRecordDecls in C++")::llvm::llvm_unreachable_internal("There are only CXXRecordDecls in C++"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3746);
3747}

3749Decl *
3750TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
  ClassTemplateSpecializationDecl *D) {
// As a MS extension, we permit class-scope explicit specialization
// of member class templates.
ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
assert(ClassTemplate->getDeclContext()->isRecord() &&(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3758, __extension__
 __PRETTY_FUNCTION__))
       D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3758, __extension__
 __PRETTY_FUNCTION__))
       "can only instantiate an explicit specialization "(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3758, __extension__
 __PRETTY_FUNCTION__))
       "for a member class template")(static_cast <bool> (ClassTemplate->getDeclContext()
->isRecord() && D->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization && "can only instantiate an explicit specialization "
 "for a member class template") ? void (0) : __assert_fail ("ClassTemplate->getDeclContext()->isRecord() && D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && \"can only instantiate an explicit specialization \" \"for a member class template\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3758, __extension__
 __PRETTY_FUNCTION__));

// Lookup the already-instantiated declaration in the instantiation
// of the class template.
ClassTemplateDecl *InstClassTemplate =
    cast_or_null<ClassTemplateDecl>(SemaRef.FindInstantiatedDecl(
        D->getLocation(), ClassTemplate, TemplateArgs));
if (!InstClassTemplate)
  return nullptr;

// Substitute into the template arguments of the class template explicit
// specialization.
TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
                                      castAs<TemplateSpecializationTypeLoc>();
TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
                                          Loc.getRAngleLoc());
SmallVector<TemplateArgumentLoc, 4> ArgLocs;
for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
  ArgLocs.push_back(Loc.getArgLoc(I));
if (SemaRef.SubstTemplateArguments(ArgLocs, TemplateArgs, InstTemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (SemaRef.CheckTemplateArgumentList(InstClassTemplate, D->getLocation(),
                                      InstTemplateArgs, false,
                                      SugaredConverted, CanonicalConverted,
                                      /*UpdateArgsWithConversions=*/true))
  return nullptr;

// Figure out where to insert this class template explicit specialization
// in the member template's set of class template explicit specializations.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl =
    InstClassTemplate->findSpecialization(CanonicalConverted, InsertPos);

// Check whether we've already seen a conflicting instantiation of this
// declaration (for instance, if there was a prior implicit instantiation).
bool Ignored;
if (PrevDecl &&
    SemaRef.CheckSpecializationInstantiationRedecl(D->getLocation(),
                                                   D->getSpecializationKind(),
                                                   PrevDecl,
                                                   PrevDecl->getSpecializationKind(),
                                                   PrevDecl->getPointOfInstantiation(),
                                                   Ignored))
  return nullptr;

// If PrevDecl was a definition and D is also a definition, diagnose.
// This happens in cases like:
//
//   template<typename T, typename U>
//   struct Outer {
//     template<typename X> struct Inner;
//     template<> struct Inner<T> {};
//     template<> struct Inner<U> {};
//   };
//
//   Outer<int, int> outer; // error: the explicit specializations of Inner
//                          // have the same signature.
if (PrevDecl && PrevDecl->getDefinition() &&
    D->isThisDeclarationADefinition()) {
  SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
  SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
               diag::note_previous_definition);
  return nullptr;
}

// Create the class template partial specialization declaration.
ClassTemplateSpecializationDecl *InstD =
    ClassTemplateSpecializationDecl::Create(
        SemaRef.Context, D->getTagKind(), Owner, D->getBeginLoc(),
        D->getLocation(), InstClassTemplate, CanonicalConverted, PrevDecl);

// Add this partial specialization to the set of class template partial
// specializations.
if (!PrevDecl)
  InstClassTemplate->AddSpecialization(InstD, InsertPos);

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, InstD))
  return nullptr;

// Build the canonical type that describes the converted template
// arguments of the class template explicit specialization.
QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
    TemplateName(InstClassTemplate), CanonicalConverted,
    SemaRef.Context.getRecordType(InstD));

// 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 = SemaRef.Context.getTemplateSpecializationTypeInfo(
    TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
    CanonType);

InstD->setAccess(D->getAccess());
InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
InstD->setSpecializationKind(D->getSpecializationKind());
InstD->setTypeAsWritten(WrittenTy);
InstD->setExternLoc(D->getExternLoc());
InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());

Owner->addDecl(InstD);

// Instantiate the members of the class-scope explicit specialization eagerly.
// We don't have support for lazy instantiation of an explicit specialization
// yet, and MSVC eagerly instantiates in this case.
// FIXME: This is wrong in standard C++.
if (D->isThisDeclarationADefinition() &&
    SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
                             TSK_ImplicitInstantiation,
                             /*Complain=*/true))
  return nullptr;

return InstD;
3879}

3881Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
  VarTemplateSpecializationDecl *D) {

TemplateArgumentListInfo VarTemplateArgsInfo;
VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
assert(VarTemplate &&(static_cast <bool> (VarTemplate && "A template specialization without specialized template?"
) ? void (0) : __assert_fail ("VarTemplate && \"A template specialization without specialized template?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3887, __extension__
 __PRETTY_FUNCTION__))
       "A template specialization without specialized template?")(static_cast <bool> (VarTemplate && "A template specialization without specialized template?"
) ? void (0) : __assert_fail ("VarTemplate && \"A template specialization without specialized template?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3887, __extension__
 __PRETTY_FUNCTION__));

VarTemplateDecl *InstVarTemplate =
    cast_or_null<VarTemplateDecl>(SemaRef.FindInstantiatedDecl(
        D->getLocation(), VarTemplate, TemplateArgs));
if (!InstVarTemplate)
  return nullptr;

// Substitute the current template arguments.
if (const ASTTemplateArgumentListInfo *TemplateArgsInfo =
        D->getTemplateArgsInfo()) {
  VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
  VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo->getRAngleLoc());

  if (SemaRef.SubstTemplateArguments(TemplateArgsInfo->arguments(),
                                     TemplateArgs, VarTemplateArgsInfo))
    return nullptr;
}

// Check that the template argument list is well-formed for this template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (SemaRef.CheckTemplateArgumentList(InstVarTemplate, D->getLocation(),
                                      VarTemplateArgsInfo, false,
                                      SugaredConverted, CanonicalConverted,
                                      /*UpdateArgsWithConversions=*/true))
  return nullptr;

// Check whether we've already seen a declaration of this specialization.
void *InsertPos = nullptr;
VarTemplateSpecializationDecl *PrevDecl =
    InstVarTemplate->findSpecialization(CanonicalConverted, InsertPos);

// Check whether we've already seen a conflicting instantiation of this
// declaration (for instance, if there was a prior implicit instantiation).
bool Ignored;
if (PrevDecl && SemaRef.CheckSpecializationInstantiationRedecl(
                    D->getLocation(), D->getSpecializationKind(), PrevDecl,
                    PrevDecl->getSpecializationKind(),
                    PrevDecl->getPointOfInstantiation(), Ignored))
  return nullptr;

return VisitVarTemplateSpecializationDecl(
    InstVarTemplate, D, VarTemplateArgsInfo, CanonicalConverted, PrevDecl);
3930}

3932Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
  VarTemplateDecl *VarTemplate, VarDecl *D,
  const TemplateArgumentListInfo &TemplateArgsInfo,
  ArrayRef<TemplateArgument> Converted,
  VarTemplateSpecializationDecl *PrevDecl) {

// Do substitution on the type of the declaration
TypeSourceInfo *DI =
    SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
                      D->getTypeSpecStartLoc(), D->getDeclName());
if (!DI)
  return nullptr;

if (DI->getType()->isFunctionType()) {
  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
      << D->isStaticDataMember() << DI->getType();
  return nullptr;
}

// Build the instantiated declaration
VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
    SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
    VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
Var->setTemplateArgsInfo(TemplateArgsInfo);
if (!PrevDecl) {
  void *InsertPos = nullptr;
  VarTemplate->findSpecialization(Converted, InsertPos);
  VarTemplate->AddSpecialization(Var, InsertPos);
}

if (SemaRef.getLangOpts().OpenCL)
  SemaRef.deduceOpenCLAddressSpace(Var);

// Substitute the nested name specifier, if any.
if (SubstQualifier(D, Var))
  return nullptr;

SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
                                   StartingScope, false, PrevDecl);

return Var;
3973}

3975Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
llvm_unreachable("@defs is not supported in Objective-C++")::llvm::llvm_unreachable_internal("@defs is not supported in Objective-C++"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3976);
3977}

3979Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
// FIXME: We need to be able to instantiate FriendTemplateDecls.
unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
                                             DiagnosticsEngine::Error,
                                             "cannot instantiate %0 yet");
SemaRef.Diag(D->getLocation(), DiagID)
  << D->getDeclKindName();

return nullptr;
3988}

3990Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
llvm_unreachable("Concept definitions cannot reside inside a template")::llvm::llvm_unreachable_internal("Concept definitions cannot reside inside a template"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3991);
3992}

3994Decl *TemplateDeclInstantiator::VisitImplicitConceptSpecializationDecl(
  ImplicitConceptSpecializationDecl *D) {
llvm_unreachable("Concept specializations cannot reside inside a template")::llvm::llvm_unreachable_internal("Concept specializations cannot reside inside a template"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 3996);
3997}

3999Decl *
4000TemplateDeclInstantiator::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
return RequiresExprBodyDecl::Create(SemaRef.Context, D->getDeclContext(),
                                    D->getBeginLoc());
4003}

4005Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
llvm_unreachable("Unexpected decl")::llvm::llvm_unreachable_internal("Unexpected decl", "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4006);
4007}

4009Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
                    const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
if (D->isInvalidDecl())
  return nullptr;

Decl *SubstD;
runWithSufficientStackSpace(D->getLocation(), [&] {
  SubstD = Instantiator.Visit(D);
});
return SubstD;
4020}

4022void TemplateDeclInstantiator::adjustForRewrite(RewriteKind RK,
                                              FunctionDecl *Orig, QualType &T,
                                              TypeSourceInfo *&TInfo,
                                              DeclarationNameInfo &NameInfo) {
assert(RK == RewriteKind::RewriteSpaceshipAsEqualEqual)(static_cast <bool> (RK == RewriteKind::RewriteSpaceshipAsEqualEqual
) ? void (0) : __assert_fail ("RK == RewriteKind::RewriteSpaceshipAsEqualEqual"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4026, __extension__
 __PRETTY_FUNCTION__));

// C++2a [class.compare.default]p3:
//   the return type is replaced with bool
auto *FPT = T->castAs<FunctionProtoType>();
T = SemaRef.Context.getFunctionType(
    SemaRef.Context.BoolTy, FPT->getParamTypes(), FPT->getExtProtoInfo());

// Update the return type in the source info too. The most straightforward
// way is to create new TypeSourceInfo for the new type. Use the location of
// the '= default' as the location of the new type.
//
// FIXME: Set the correct return type when we initially transform the type,
// rather than delaying it to now.
TypeSourceInfo *NewTInfo =
    SemaRef.Context.getTrivialTypeSourceInfo(T, Orig->getEndLoc());
auto OldLoc = TInfo->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>();
assert(OldLoc && "type of function is not a function type?")(static_cast <bool> (OldLoc && "type of function is not a function type?"
) ? void (0) : __assert_fail ("OldLoc && \"type of function is not a function type?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4043, __extension__
 __PRETTY_FUNCTION__));
auto NewLoc = NewTInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>();
for (unsigned I = 0, N = OldLoc.getNumParams(); I != N; ++I)
  NewLoc.setParam(I, OldLoc.getParam(I));
TInfo = NewTInfo;

//   and the declarator-id is replaced with operator==
NameInfo.setName(
    SemaRef.Context.DeclarationNames.getCXXOperatorName(OO_EqualEqual));
4052}

4054FunctionDecl *Sema::SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
                                             FunctionDecl *Spaceship) {
if (Spaceship->isInvalidDecl())
  return nullptr;

// C++2a [class.compare.default]p3:
//   an == operator function is declared implicitly [...] with the same
//   access and function-definition and in the same class scope as the
//   three-way comparison operator function
MultiLevelTemplateArgumentList NoTemplateArgs;
NoTemplateArgs.setKind(TemplateSubstitutionKind::Rewrite);
NoTemplateArgs.addOuterRetainedLevels(RD->getTemplateDepth());
TemplateDeclInstantiator Instantiator(*this, RD, NoTemplateArgs);
Decl *R;
if (auto *MD = dyn_cast<CXXMethodDecl>(Spaceship)) {
  R = Instantiator.VisitCXXMethodDecl(
      MD, nullptr, std::nullopt,
      TemplateDeclInstantiator::RewriteKind::RewriteSpaceshipAsEqualEqual);
} else {
  assert(Spaceship->getFriendObjectKind() &&(static_cast <bool> (Spaceship->getFriendObjectKind(
) && "defaulted spaceship is neither a member nor a friend"
) ? void (0) : __assert_fail ("Spaceship->getFriendObjectKind() && \"defaulted spaceship is neither a member nor a friend\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4074, __extension__
 __PRETTY_FUNCTION__))
         "defaulted spaceship is neither a member nor a friend")(static_cast <bool> (Spaceship->getFriendObjectKind(
) && "defaulted spaceship is neither a member nor a friend"
) ? void (0) : __assert_fail ("Spaceship->getFriendObjectKind() && \"defaulted spaceship is neither a member nor a friend\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4074, __extension__
 __PRETTY_FUNCTION__));

  R = Instantiator.VisitFunctionDecl(
      Spaceship, nullptr,
      TemplateDeclInstantiator::RewriteKind::RewriteSpaceshipAsEqualEqual);
  if (!R)
    return nullptr;

  FriendDecl *FD =
      FriendDecl::Create(Context, RD, Spaceship->getLocation(),
                         cast<NamedDecl>(R), Spaceship->getBeginLoc());
  FD->setAccess(AS_public);
  RD->addDecl(FD);
}
return cast_or_null<FunctionDecl>(R);
4089}

4091/// Instantiates a nested template parameter list in the current
4092/// instantiation context.
4093///
4094/// \param L The parameter list to instantiate
4095///
4096/// \returns NULL if there was an error
4097TemplateParameterList *
4098TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
// Get errors for all the parameters before bailing out.
bool Invalid = false;

unsigned N = L->size();
typedef SmallVector<NamedDecl *, 8> ParamVector;
ParamVector Params;
Params.reserve(N);
for (auto &P : *L) {
  NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
  Params.push_back(D);
  Invalid = Invalid || !D || D->isInvalidDecl();
}

// Clean up if we had an error.
if (Invalid)
  return nullptr;

Expr *InstRequiresClause = L->getRequiresClause();

TemplateParameterList *InstL
  = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
                                  L->getLAngleLoc(), Params,
                                  L->getRAngleLoc(), InstRequiresClause);
return InstL;
4123}

4125TemplateParameterList *
4126Sema::SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        bool EvaluateConstraints) {
TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
Instantiator.setEvaluateConstraints(EvaluateConstraints);
return Instantiator.SubstTemplateParams(Params);
4132}

4134/// Instantiate the declaration of a class template partial
4135/// specialization.
4136///
4137/// \param ClassTemplate the (instantiated) class template that is partially
4138// specialized by the instantiation of \p PartialSpec.
4139///
4140/// \param PartialSpec the (uninstantiated) class template partial
4141/// specialization that we are instantiating.
4142///
4143/// \returns The instantiated partial specialization, if successful; otherwise,
4144/// NULL to indicate an error.
4145ClassTemplatePartialSpecializationDecl *
4146TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
                                          ClassTemplateDecl *ClassTemplate,
                        ClassTemplatePartialSpecializationDecl *PartialSpec) {
// Create a local instantiation scope for this class template partial
// specialization, which will contain the instantiations of the template
// parameters.
LocalInstantiationScope Scope(SemaRef);

// Substitute into the template parameters of the class template partial
// specialization.
TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

// Substitute into the template arguments of the class template partial
// specialization.
const ASTTemplateArgumentListInfo *TemplArgInfo
  = PartialSpec->getTemplateArgsAsWritten();
TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
                                          TemplArgInfo->RAngleLoc);
if (SemaRef.SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
                                   InstTemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (SemaRef.CheckTemplateArgumentList(
        ClassTemplate, PartialSpec->getLocation(), InstTemplateArgs,
        /*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted))
  return nullptr;

// Check these arguments are valid for a template partial specialization.
if (SemaRef.CheckTemplatePartialSpecializationArgs(
        PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
        CanonicalConverted))
  return nullptr;

// Figure out where to insert this class template partial specialization
// in the member template's set of class template partial specializations.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl =
    ClassTemplate->findPartialSpecialization(CanonicalConverted, InstParams,
                                             InsertPos);

// Build the canonical type that describes the converted template
// arguments of the class template partial specialization.
QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
    TemplateName(ClassTemplate), CanonicalConverted);

// 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
  = SemaRef.Context.getTemplateSpecializationTypeInfo(
                                                  TemplateName(ClassTemplate),
                                                  PartialSpec->getLocation(),
                                                  InstTemplateArgs,
                                                  CanonType);

if (PrevDecl) {
  // We've already seen a partial specialization with the same template
  // parameters and template arguments. This can happen, for example, when
  // substituting the outer template arguments ends up causing two
  // class template partial specializations of a member class template
  // to have identical forms, e.g.,
  //
  //   template<typename T, typename U>
  //   struct Outer {
  //     template<typename X, typename Y> struct Inner;
  //     template<typename Y> struct Inner<T, Y>;
  //     template<typename Y> struct Inner<U, Y>;
  //   };
  //
  //   Outer<int, int> outer; // error: the partial specializations of Inner
  //                          // have the same signature.
  SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
    << WrittenTy->getType();
  SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
    << SemaRef.Context.getTypeDeclType(PrevDecl);
  return nullptr;
}


// Create the class template partial specialization declaration.
ClassTemplatePartialSpecializationDecl *InstPartialSpec =
    ClassTemplatePartialSpecializationDecl::Create(
        SemaRef.Context, PartialSpec->getTagKind(), Owner,
        PartialSpec->getBeginLoc(), PartialSpec->getLocation(), InstParams,
        ClassTemplate, CanonicalConverted, InstTemplateArgs, CanonType,
        nullptr);
// Substitute the nested name specifier, if any.
if (SubstQualifier(PartialSpec, InstPartialSpec))
  return nullptr;

InstPartialSpec->setInstantiatedFromMember(PartialSpec);
InstPartialSpec->setTypeAsWritten(WrittenTy);

// Check the completed partial specialization.
SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);

// Add this partial specialization to the set of class template partial
// specializations.
ClassTemplate->AddPartialSpecialization(InstPartialSpec,
                                        /*InsertPos=*/nullptr);
return InstPartialSpec;
4257}

4259/// Instantiate the declaration of a variable template partial
4260/// specialization.
4261///
4262/// \param VarTemplate the (instantiated) variable template that is partially
4263/// specialized by the instantiation of \p PartialSpec.
4264///
4265/// \param PartialSpec the (uninstantiated) variable template partial
4266/// specialization that we are instantiating.
4267///
4268/// \returns The instantiated partial specialization, if successful; otherwise,
4269/// NULL to indicate an error.
4270VarTemplatePartialSpecializationDecl *
4271TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
  VarTemplateDecl *VarTemplate,
  VarTemplatePartialSpecializationDecl *PartialSpec) {
// Create a local instantiation scope for this variable template partial
// specialization, which will contain the instantiations of the template
// parameters.
LocalInstantiationScope Scope(SemaRef);

// Substitute into the template parameters of the variable template partial
// specialization.
TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
if (!InstParams)
  return nullptr;

// Substitute into the template arguments of the variable template partial
// specialization.
const ASTTemplateArgumentListInfo *TemplArgInfo
  = PartialSpec->getTemplateArgsAsWritten();
TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
                                          TemplArgInfo->RAngleLoc);
if (SemaRef.SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
                                   InstTemplateArgs))
  return nullptr;

// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (SemaRef.CheckTemplateArgumentList(
        VarTemplate, PartialSpec->getLocation(), InstTemplateArgs,
        /*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted))
  return nullptr;

// Check these arguments are valid for a template partial specialization.
if (SemaRef.CheckTemplatePartialSpecializationArgs(
        PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
        CanonicalConverted))
  return nullptr;

// Figure out where to insert this variable template partial specialization
// in the member template's set of variable template partial specializations.
void *InsertPos = nullptr;
VarTemplateSpecializationDecl *PrevDecl =
    VarTemplate->findPartialSpecialization(CanonicalConverted, InstParams,
                                           InsertPos);

// Build the canonical type that describes the converted template
// arguments of the variable template partial specialization.
QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
    TemplateName(VarTemplate), CanonicalConverted);

// Build the fully-sugared type for this variable 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 = SemaRef.Context.getTemplateSpecializationTypeInfo(
    TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
    CanonType);

if (PrevDecl) {
  // We've already seen a partial specialization with the same template
  // parameters and template arguments. This can happen, for example, when
  // substituting the outer template arguments ends up causing two
  // variable template partial specializations of a member variable template
  // to have identical forms, e.g.,
  //
  //   template<typename T, typename U>
  //   struct Outer {
  //     template<typename X, typename Y> pair<X,Y> p;
  //     template<typename Y> pair<T, Y> p;
  //     template<typename Y> pair<U, Y> p;
  //   };
  //
  //   Outer<int, int> outer; // error: the partial specializations of Inner
  //                          // have the same signature.
  SemaRef.Diag(PartialSpec->getLocation(),
               diag::err_var_partial_spec_redeclared)
      << WrittenTy->getType();
  SemaRef.Diag(PrevDecl->getLocation(),
               diag::note_var_prev_partial_spec_here);
  return nullptr;
}

// Do substitution on the type of the declaration
TypeSourceInfo *DI = SemaRef.SubstType(
    PartialSpec->getTypeSourceInfo(), TemplateArgs,
    PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
if (!DI)
  return nullptr;

if (DI->getType()->isFunctionType()) {
  SemaRef.Diag(PartialSpec->getLocation(),
               diag::err_variable_instantiates_to_function)
      << PartialSpec->isStaticDataMember() << DI->getType();
  return nullptr;
}

// Create the variable template partial specialization declaration.
VarTemplatePartialSpecializationDecl *InstPartialSpec =
    VarTemplatePartialSpecializationDecl::Create(
        SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
        PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
        DI, PartialSpec->getStorageClass(), CanonicalConverted,
        InstTemplateArgs);

// Substitute the nested name specifier, if any.
if (SubstQualifier(PartialSpec, InstPartialSpec))
  return nullptr;

InstPartialSpec->setInstantiatedFromMember(PartialSpec);
InstPartialSpec->setTypeAsWritten(WrittenTy);

// Check the completed partial specialization.
SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);

// Add this partial specialization to the set of variable template partial
// specializations. The instantiation of the initializer is not necessary.
VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);

SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
                                   LateAttrs, Owner, StartingScope);

return InstPartialSpec;
4397}

4399TypeSourceInfo*
4400TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
                            SmallVectorImpl<ParmVarDecl *> &Params) {
TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
assert(OldTInfo && "substituting function without type source info")(static_cast <bool> (OldTInfo && "substituting function without type source info"
) ? void (0) : __assert_fail ("OldTInfo && \"substituting function without type source info\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4403, __extension__
 __PRETTY_FUNCTION__));
assert(Params.empty() && "parameter vector is non-empty at start")(static_cast <bool> (Params.empty() && "parameter vector is non-empty at start"
) ? void (0) : __assert_fail ("Params.empty() && \"parameter vector is non-empty at start\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4404, __extension__
 __PRETTY_FUNCTION__));

CXXRecordDecl *ThisContext = nullptr;
Qualifiers ThisTypeQuals;
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
  ThisContext = cast<CXXRecordDecl>(Owner);
  ThisTypeQuals = Method->getMethodQualifiers();
}

TypeSourceInfo *NewTInfo = SemaRef.SubstFunctionDeclType(
    OldTInfo, TemplateArgs, D->getTypeSpecStartLoc(), D->getDeclName(),
    ThisContext, ThisTypeQuals, EvaluateConstraints);
if (!NewTInfo)
  return nullptr;

TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
  if (NewTInfo != OldTInfo) {
    // Get parameters from the new type info.
    TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
    FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
    unsigned NewIdx = 0;
    for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
         OldIdx != NumOldParams; ++OldIdx) {
      ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
      if (!OldParam)
        return nullptr;

      LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;

      std::optional<unsigned> NumArgumentsInExpansion;
      if (OldParam->isParameterPack())
        NumArgumentsInExpansion =
            SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
                                               TemplateArgs);
      if (!NumArgumentsInExpansion) {
        // Simple case: normal parameter, or a parameter pack that's
        // instantiated to a (still-dependent) parameter pack.
        ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
        Params.push_back(NewParam);
        Scope->InstantiatedLocal(OldParam, NewParam);
      } else {
        // Parameter pack expansion: make the instantiation an argument pack.
        Scope->MakeInstantiatedLocalArgPack(OldParam);
        for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
          ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
          Params.push_back(NewParam);
          Scope->InstantiatedLocalPackArg(OldParam, NewParam);
        }
      }
    }
  } else {
    // The function type itself was not dependent and therefore no
    // substitution occurred. However, we still need to instantiate
    // the function parameters themselves.
    const FunctionProtoType *OldProto =
        cast<FunctionProtoType>(OldProtoLoc.getType());
    for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
         ++i) {
      ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
      if (!OldParam) {
        Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
            D, D->getLocation(), OldProto->getParamType(i)));
        continue;
      }

      ParmVarDecl *Parm =
          cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
      if (!Parm)
        return nullptr;
      Params.push_back(Parm);
    }
  }
} else {
  // If the type of this function, after ignoring parentheses, is not
  // *directly* a function type, then we're instantiating a function that
  // was declared via a typedef or with attributes, e.g.,
  //
  //   typedef int functype(int, int);
  //   functype func;
  //   int __cdecl meth(int, int);
  //
  // In this case, we'll just go instantiate the ParmVarDecls that we
  // synthesized in the method declaration.
  SmallVector<QualType, 4> ParamTypes;
  Sema::ExtParameterInfoBuilder ExtParamInfos;
  if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
                             TemplateArgs, ParamTypes, &Params,
                             ExtParamInfos))
    return nullptr;
}

return NewTInfo;
4497}

4499/// Introduce the instantiated function parameters into the local
4500/// instantiation scope, and set the parameter names to those used
4501/// in the template.
4502bool Sema::addInstantiatedParametersToScope(
  FunctionDecl *Function, const FunctionDecl *PatternDecl,
  LocalInstantiationScope &Scope,
  const MultiLevelTemplateArgumentList &TemplateArgs) {
unsigned FParamIdx = 0;
for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
  const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
  if (!PatternParam->isParameterPack()) {
    // Simple case: not a parameter pack.
    assert(FParamIdx < Function->getNumParams())(static_cast <bool> (FParamIdx < Function->getNumParams
()) ? void (0) : __assert_fail ("FParamIdx < Function->getNumParams()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4511, __extension__
 __PRETTY_FUNCTION__));
    ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
    FunctionParam->setDeclName(PatternParam->getDeclName());
    // If the parameter's type is not dependent, update it to match the type
    // in the pattern. They can differ in top-level cv-qualifiers, and we want
    // the pattern's type here. If the type is dependent, they can't differ,
    // per core issue 1668. Substitute into the type from the pattern, in case
    // it's instantiation-dependent.
    // FIXME: Updating the type to work around this is at best fragile.
    if (!PatternDecl->getType()->isDependentType()) {
      QualType T = SubstType(PatternParam->getType(), TemplateArgs,
                             FunctionParam->getLocation(),
                             FunctionParam->getDeclName());
      if (T.isNull())
        return true;
      FunctionParam->setType(T);
    }

    Scope.InstantiatedLocal(PatternParam, FunctionParam);
    ++FParamIdx;
    continue;
  }

  // Expand the parameter pack.
  Scope.MakeInstantiatedLocalArgPack(PatternParam);
  std::optional<unsigned> NumArgumentsInExpansion =
      getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
  if (NumArgumentsInExpansion) {
    QualType PatternType =
        PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
    for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
      ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
      FunctionParam->setDeclName(PatternParam->getDeclName());
      if (!PatternDecl->getType()->isDependentType()) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, Arg);
        QualType T =
            SubstType(PatternType, TemplateArgs, FunctionParam->getLocation(),
                      FunctionParam->getDeclName());
        if (T.isNull())
          return true;
        FunctionParam->setType(T);
      }

      Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
      ++FParamIdx;
    }
  }
}

return false;
4561}

4563bool Sema::InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
                                    ParmVarDecl *Param) {
assert(Param->hasUninstantiatedDefaultArg())(static_cast <bool> (Param->hasUninstantiatedDefaultArg
()) ? void (0) : __assert_fail ("Param->hasUninstantiatedDefaultArg()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4565, __extension__
 __PRETTY_FUNCTION__));

// Instantiate the expression.
//
// FIXME: Pass in a correct Pattern argument, otherwise
// getTemplateInstantiationArgs uses the lexical context of FD, e.g.
//
// template<typename T>
// struct A {
//   static int FooImpl();
//
//   template<typename Tp>
//   // bug: default argument A<T>::FooImpl() is evaluated with 2-level
//   // template argument list [[T], [Tp]], should be [[Tp]].
//   friend A<Tp> Foo(int a);
// };
//
// template<typename T>
// A<T> Foo(int a = A<T>::FooImpl());
MultiLevelTemplateArgumentList TemplateArgs = getTemplateInstantiationArgs(
    FD, /*Final=*/false, nullptr, /*RelativeToPrimary=*/true);

if (SubstDefaultArgument(CallLoc, Param, TemplateArgs, /*ForCallExpr*/ true))
  return true;

if (ASTMutationListener *L = getASTMutationListener())
  L->DefaultArgumentInstantiated(Param);

return false;
4594}

4596void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                  FunctionDecl *Decl) {
const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
if (Proto->getExceptionSpecType() != EST_Uninstantiated)
  return;

InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
                           InstantiatingTemplate::ExceptionSpecification());
if (Inst.isInvalid()) {
  // We hit the instantiation depth limit. Clear the exception specification
  // so that our callers don't have to cope with EST_Uninstantiated.
  UpdateExceptionSpec(Decl, EST_None);
  return;
}
if (Inst.isAlreadyInstantiating()) {
  // This exception specification indirectly depends on itself. Reject.
  // FIXME: Corresponding rule in the standard?
  Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
  UpdateExceptionSpec(Decl, EST_None);
  return;
}

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
Sema::ContextRAII savedContext(*this, Decl);
LocalInstantiationScope Scope(*this);

MultiLevelTemplateArgumentList TemplateArgs = getTemplateInstantiationArgs(
    Decl, /*Final=*/false, nullptr, /*RelativeToPrimary*/ true);

// FIXME: We can't use getTemplateInstantiationPattern(false) in general
// here, because for a non-defining friend declaration in a class template,
// we don't store enough information to map back to the friend declaration in
// the template.
FunctionDecl *Template = Proto->getExceptionSpecTemplate();
if (addInstantiatedParametersToScope(Decl, Template, Scope, TemplateArgs)) {
  UpdateExceptionSpec(Decl, EST_None);
  return;
}

SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
                   TemplateArgs);
4638}

4640/// Initializes the common fields of an instantiation function
4641/// declaration (New) from the corresponding fields of its template (Tmpl).
4642///
4643/// \returns true if there was an error
4644bool
4645TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
                                                  FunctionDecl *Tmpl) {
New->setImplicit(Tmpl->isImplicit());

// Forward the mangling number from the template to the instantiated decl.
SemaRef.Context.setManglingNumber(New,
                                  SemaRef.Context.getManglingNumber(Tmpl));

// If we are performing substituting explicitly-specified template arguments
// or deduced template arguments into a function template and we reach this
// point, we are now past the point where SFINAE applies and have committed
// to keeping the new function template specialization. We therefore
// convert the active template instantiation for the function template
// into a template instantiation for this specific function template
// specialization, which is not a SFINAE context, so that we diagnose any
// further errors in the declaration itself.
//
// FIXME: This is a hack.
typedef Sema::CodeSynthesisContext ActiveInstType;
ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
    ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
  if (isa<FunctionTemplateDecl>(ActiveInst.Entity)) {
    SemaRef.InstantiatingSpecializations.erase(
        {ActiveInst.Entity->getCanonicalDecl(), ActiveInst.Kind});
    atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
    ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
    ActiveInst.Entity = New;
    atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
  }
}

const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
assert(Proto && "Function template without prototype?")(static_cast <bool> (Proto && "Function template without prototype?"
) ? void (0) : __assert_fail ("Proto && \"Function template without prototype?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4678, __extension__
 __PRETTY_FUNCTION__));

if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
  FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();

  // DR1330: In C++11, defer instantiation of a non-trivial
  // exception specification.
  // DR1484: Local classes and their members are instantiated along with the
  // containing function.
  if (SemaRef.getLangOpts().CPlusPlus11 &&
      EPI.ExceptionSpec.Type != EST_None &&
      EPI.ExceptionSpec.Type != EST_DynamicNone &&
      EPI.ExceptionSpec.Type != EST_BasicNoexcept &&
      !Tmpl->isInLocalScopeForInstantiation()) {
    FunctionDecl *ExceptionSpecTemplate = Tmpl;
    if (EPI.ExceptionSpec.Type == EST_Uninstantiated)
      ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
    ExceptionSpecificationType NewEST = EST_Uninstantiated;
    if (EPI.ExceptionSpec.Type == EST_Unevaluated)
      NewEST = EST_Unevaluated;

    // Mark the function has having an uninstantiated exception specification.
    const FunctionProtoType *NewProto
      = New->getType()->getAs<FunctionProtoType>();
    assert(NewProto && "Template instantiation without function prototype?")(static_cast <bool> (NewProto && "Template instantiation without function prototype?"
) ? void (0) : __assert_fail ("NewProto && \"Template instantiation without function prototype?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4702, __extension__
 __PRETTY_FUNCTION__));
    EPI = NewProto->getExtProtoInfo();
    EPI.ExceptionSpec.Type = NewEST;
    EPI.ExceptionSpec.SourceDecl = New;
    EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
    New->setType(SemaRef.Context.getFunctionType(
        NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
  } else {
    Sema::ContextRAII SwitchContext(SemaRef, New);
    SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
  }
}

// Get the definition. Leaves the variable unchanged if undefined.
const FunctionDecl *Definition = Tmpl;
Tmpl->isDefined(Definition);

SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
                         LateAttrs, StartingScope);

return false;
4723}

4725/// Initializes common fields of an instantiated method
4726/// declaration (New) from the corresponding fields of its template
4727/// (Tmpl).
4728///
4729/// \returns true if there was an error
4730bool
4731TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
                                                CXXMethodDecl *Tmpl) {
if (InitFunctionInstantiation(New, Tmpl))
  return true;

if (isa<CXXDestructorDecl>(New) && SemaRef.getLangOpts().CPlusPlus11)
  SemaRef.AdjustDestructorExceptionSpec(cast<CXXDestructorDecl>(New));

New->setAccess(Tmpl->getAccess());
if (Tmpl->isVirtualAsWritten())
  New->setVirtualAsWritten(true);

// FIXME: New needs a pointer to Tmpl
return false;
4745}

4747bool TemplateDeclInstantiator::SubstDefaultedFunction(FunctionDecl *New,
                                                    FunctionDecl *Tmpl) {
// Transfer across any unqualified lookups.
if (auto *DFI = Tmpl->getDefaultedFunctionInfo()) {
  SmallVector<DeclAccessPair, 32> Lookups;
  Lookups.reserve(DFI->getUnqualifiedLookups().size());
  bool AnyChanged = false;
  for (DeclAccessPair DA : DFI->getUnqualifiedLookups()) {
    NamedDecl *D = SemaRef.FindInstantiatedDecl(New->getLocation(),
                                                DA.getDecl(), TemplateArgs);
    if (!D)
      return true;
    AnyChanged |= (D != DA.getDecl());
    Lookups.push_back(DeclAccessPair::make(D, DA.getAccess()));
  }

  // It's unlikely that substitution will change any declarations. Don't
  // store an unnecessary copy in that case.
  New->setDefaultedFunctionInfo(
      AnyChanged ? FunctionDecl::DefaultedFunctionInfo::Create(
                       SemaRef.Context, Lookups)
                 : DFI);
}

SemaRef.SetDeclDefaulted(New, Tmpl->getLocation());
return false;
4773}

4775/// Instantiate (or find existing instantiation of) a function template with a
4776/// given set of template arguments.
4777///
4778/// Usually this should not be used, and template argument deduction should be
4779/// used in its place.
4780FunctionDecl *
4781Sema::InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
                                   const TemplateArgumentList *Args,
                                   SourceLocation Loc) {
FunctionDecl *FD = FTD->getTemplatedDecl();

sema::TemplateDeductionInfo Info(Loc);
InstantiatingTemplate Inst(
    *this, Loc, FTD, Args->asArray(),
    CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
if (Inst.isInvalid())
  return nullptr;

ContextRAII SavedContext(*this, FD);
MultiLevelTemplateArgumentList MArgs(FTD, Args->asArray(),
                                     /*Final=*/false);

return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
4798}

4800/// Instantiate the definition of the given function from its
4801/// template.
4802///
4803/// \param PointOfInstantiation the point at which the instantiation was
4804/// required. Note that this is not precisely a "point of instantiation"
4805/// for the function, but it's close.
4806///
4807/// \param Function the already-instantiated declaration of a
4808/// function template specialization or member function of a class template
4809/// specialization.
4810///
4811/// \param Recursive if true, recursively instantiates any functions that
4812/// are required by this instantiation.
4813///
4814/// \param DefinitionRequired if true, then we are performing an explicit
4815/// instantiation where the body of the function is required. Complain if
4816/// there is no such body.
4817void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                       FunctionDecl *Function,
                                       bool Recursive,
                                       bool DefinitionRequired,
                                       bool AtEndOfTU) {
if (Function->isInvalidDecl() || isa<CXXDeductionGuideDecl>(Function))
  return;

// Never instantiate an explicit specialization except if it is a class scope
// explicit specialization.
TemplateSpecializationKind TSK =
    Function->getTemplateSpecializationKindForInstantiation();
if (TSK == TSK_ExplicitSpecialization)
  return;

// Never implicitly instantiate a builtin; we don't actually need a function
// body.
if (Function->getBuiltinID() && TSK == TSK_ImplicitInstantiation &&
    !DefinitionRequired)
  return;

// Don't instantiate a definition if we already have one.
const FunctionDecl *ExistingDefn = nullptr;
if (Function->isDefined(ExistingDefn,
                        /*CheckForPendingFriendDefinition=*/true)) {
  if (ExistingDefn->isThisDeclarationADefinition())
    return;

  // If we're asked to instantiate a function whose body comes from an
  // instantiated friend declaration, attach the instantiated body to the
  // corresponding declaration of the function.
  assert(ExistingDefn->isThisDeclarationInstantiatedFromAFriendDefinition())(static_cast <bool> (ExistingDefn->isThisDeclarationInstantiatedFromAFriendDefinition
()) ? void (0) : __assert_fail ("ExistingDefn->isThisDeclarationInstantiatedFromAFriendDefinition()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4848, __extension__
 __PRETTY_FUNCTION__));
  Function = const_cast<FunctionDecl*>(ExistingDefn);
}

// Find the function body that we'll be substituting.
const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
assert(PatternDecl && "instantiating a non-template")(static_cast <bool> (PatternDecl && "instantiating a non-template"
) ? void (0) : __assert_fail ("PatternDecl && \"instantiating a non-template\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4854, __extension__
 __PRETTY_FUNCTION__));

const FunctionDecl *PatternDef = PatternDecl->getDefinition();
Stmt *Pattern = nullptr;
if (PatternDef) {
  Pattern = PatternDef->getBody(PatternDef);
  PatternDecl = PatternDef;
  if (PatternDef->willHaveBody())
    PatternDef = nullptr;
}

// FIXME: We need to track the instantiation stack in order to know which
// definitions should be visible within this instantiation.
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
                              Function->getInstantiatedFromMemberFunction(),
                                   PatternDecl, PatternDef, TSK,
                                   /*Complain*/DefinitionRequired)) {
  if (DefinitionRequired)
    Function->setInvalidDecl();
  else if (TSK == TSK_ExplicitInstantiationDefinition ||
           (Function->isConstexpr() && !Recursive)) {
    // Try again at the end of the translation unit (at which point a
    // definition will be required).
    assert(!Recursive)(static_cast <bool> (!Recursive) ? void (0) : __assert_fail
 ("!Recursive", "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4877, __extension__ __PRETTY_FUNCTION__));
    Function->setInstantiationIsPending(true);
    PendingInstantiations.push_back(
      std::make_pair(Function, PointOfInstantiation));
  } else if (TSK == TSK_ImplicitInstantiation) {
    if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
        !getSourceManager().isInSystemHeader(PatternDecl->getBeginLoc())) {
      Diag(PointOfInstantiation, diag::warn_func_template_missing)
        << Function;
      Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
      if (getLangOpts().CPlusPlus11)
        Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
            << Function;
    }
  }

  return;
}

// Postpone late parsed template instantiations.
if (PatternDecl->isLateTemplateParsed() &&
    !LateTemplateParser) {
  Function->setInstantiationIsPending(true);
  LateParsedInstantiations.push_back(
      std::make_pair(Function, PointOfInstantiation));
  return;
}

llvm::TimeTraceScope TimeScope("InstantiateFunction", [&]() {
  std::string Name;
  llvm::raw_string_ostream OS(Name);
  Function->getNameForDiagnostic(OS, getPrintingPolicy(),
                                 /*Qualified=*/true);
  return Name;
});

// If we're performing recursive template instantiation, create our own
// queue of pending implicit instantiations that we will instantiate later,
// while we're still within our own instantiation context.
// This has to happen before LateTemplateParser below is called, so that
// it marks vtables used in late parsed templates as used.
GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                   /*Enabled=*/Recursive);
LocalEagerInstantiationScope LocalInstantiations(*this);

// Call the LateTemplateParser callback if there is a need to late parse
// a templated function definition.
if (!Pattern && PatternDecl->isLateTemplateParsed() &&
    LateTemplateParser) {
  // FIXME: Optimize to allow individual templates to be deserialized.
  if (PatternDecl->isFromASTFile())
    ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);

  auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
  assert(LPTIter != LateParsedTemplateMap.end() &&(static_cast <bool> (LPTIter != LateParsedTemplateMap.end
() && "missing LateParsedTemplate") ? void (0) : __assert_fail
 ("LPTIter != LateParsedTemplateMap.end() && \"missing LateParsedTemplate\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4932, __extension__
 __PRETTY_FUNCTION__))
         "missing LateParsedTemplate")(static_cast <bool> (LPTIter != LateParsedTemplateMap.end
() && "missing LateParsedTemplate") ? void (0) : __assert_fail
 ("LPTIter != LateParsedTemplateMap.end() && \"missing LateParsedTemplate\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4932, __extension__
 __PRETTY_FUNCTION__));
  LateTemplateParser(OpaqueParser, *LPTIter->second);
  Pattern = PatternDecl->getBody(PatternDecl);
  updateAttrsForLateParsedTemplate(PatternDecl, Function);
}

// Note, we should never try to instantiate a deleted function template.
assert((Pattern || PatternDecl->isDefaulted() ||(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4941, __extension__
 __PRETTY_FUNCTION__))
        PatternDecl->hasSkippedBody()) &&(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4941, __extension__
 __PRETTY_FUNCTION__))
       "unexpected kind of function template definition")(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4941, __extension__
 __PRETTY_FUNCTION__));

// C++1y [temp.explicit]p10:
//   Except for inline functions, declarations with types deduced from their
//   initializer or return value, and class template specializations, other
//   explicit instantiation declarations have the effect of suppressing the
//   implicit instantiation of the entity to which they refer.
if (TSK == TSK_ExplicitInstantiationDeclaration &&
    !PatternDecl->isInlined() &&
    !PatternDecl->getReturnType()->getContainedAutoType())
  return;

if (PatternDecl->isInlined()) {
  // Function, and all later redeclarations of it (from imported modules,
  // for instance), are now implicitly inline.
  for (auto *D = Function->getMostRecentDecl(); /**/;
       D = D->getPreviousDecl()) {
    D->setImplicitlyInline();
    if (D == Function)
      break;
  }
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
  return;
PrettyDeclStackTraceEntry CrashInfo(Context, Function, SourceLocation(),
                                    "instantiating function definition");

// The instantiation is visible here, even if it was first declared in an
// unimported module.
Function->setVisibleDespiteOwningModule();

// Copy the inner loc start from the pattern.
Function->setInnerLocStart(PatternDecl->getInnerLocStart());

EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// Introduce a new scope where local variable instantiations will be
// recorded, unless we're actually a member function within a local
// class, in which case we need to merge our results with the parent
// scope (of the enclosing function). The exception is instantiating
// a function template specialization, since the template to be
// instantiated already has references to locals properly substituted.
bool MergeWithParentScope = false;
if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
  MergeWithParentScope =
      Rec->isLocalClass() && !Function->isFunctionTemplateSpecialization();

LocalInstantiationScope Scope(*this, MergeWithParentScope);
auto RebuildTypeSourceInfoForDefaultSpecialMembers = [&]() {
  // Special members might get their TypeSourceInfo set up w.r.t the
  // PatternDecl context, in which case parameters could still be pointing
  // back to the original class, make sure arguments are bound to the
  // instantiated record instead.
  assert(PatternDecl->isDefaulted() &&(static_cast <bool> (PatternDecl->isDefaulted() &&
 "Special member needs to be defaulted") ? void (0) : __assert_fail
 ("PatternDecl->isDefaulted() && \"Special member needs to be defaulted\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4998, __extension__
 __PRETTY_FUNCTION__))
1
Assuming the condition is true→
2
←
'?' condition is true→
         "Special member needs to be defaulted")(static_cast <bool> (PatternDecl->isDefaulted() &&
 "Special member needs to be defaulted") ? void (0) : __assert_fail
 ("PatternDecl->isDefaulted() && \"Special member needs to be defaulted\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 4998, __extension__
 __PRETTY_FUNCTION__));
  auto PatternSM = getDefaultedFunctionKind(PatternDecl).asSpecialMember();
  if (!(PatternSM == Sema::CXXCopyConstructor ||
3
←
Assuming 'PatternSM' is not equal to CXXCopyConstructor→
6
←
Taking false branch→
        PatternSM == Sema::CXXCopyAssignment ||
4
←
Assuming 'PatternSM' is not equal to CXXCopyAssignment→
        PatternSM == Sema::CXXMoveConstructor ||
5
←
Assuming 'PatternSM' is equal to CXXMoveConstructor→
        PatternSM == Sema::CXXMoveAssignment))
    return;

  auto *NewRec = dyn_cast<CXXRecordDecl>(Function->getDeclContext());
7
←
Assuming the object is a 'CastReturnType'→
  const auto *PatternRec =
      dyn_cast<CXXRecordDecl>(PatternDecl->getDeclContext());
8
←
Assuming the object is a 'CastReturnType'→
  if (!NewRec8.1
'NewRec' is non-null
1
'NewRec' is non-null
1
'NewRec' is non-null
 || !PatternRec8.2
'PatternRec' is non-null
2
'PatternRec' is non-null
2
'PatternRec' is non-null
)
9
←
Taking false branch→
    return;
  if (!PatternRec->isLambda())
10
←
Assuming the condition is false→
11
←
Taking false branch→
    return;

  struct SpecialMemberTypeInfoRebuilder
      : TreeTransform<SpecialMemberTypeInfoRebuilder> {
    using Base = TreeTransform<SpecialMemberTypeInfoRebuilder>;
    const CXXRecordDecl *OldDecl;
    CXXRecordDecl *NewDecl;

    SpecialMemberTypeInfoRebuilder(Sema &SemaRef, const CXXRecordDecl *O,
                                   CXXRecordDecl *N)
        : TreeTransform(SemaRef), OldDecl(O), NewDecl(N) {}

    bool TransformExceptionSpec(SourceLocation Loc,
                                FunctionProtoType::ExceptionSpecInfo &ESI,
                                SmallVectorImpl<QualType> &Exceptions,
                                bool &Changed) {
      return false;
    }

    QualType TransformRecordType(TypeLocBuilder &TLB, RecordTypeLoc TL) {
      const RecordType *T = TL.getTypePtr();
      RecordDecl *Record = cast_or_null<RecordDecl>(
          getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()));
      if (Record != OldDecl)
        return Base::TransformRecordType(TLB, TL);

      QualType Result = getDerived().RebuildRecordType(NewDecl);
      if (Result.isNull())
        return QualType();

      RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
      NewTL.setNameLoc(TL.getNameLoc());
      return Result;
    }
  } IR{*this, PatternRec, NewRec};

  TypeSourceInfo *NewSI = IR.TransformType(Function->getTypeSourceInfo());
12
←
Calling 'TreeTransform::TransformType'→
  Function->setType(NewSI->getType());
  Function->setTypeSourceInfo(NewSI);

  ParmVarDecl *Parm = Function->getParamDecl(0);
  TypeSourceInfo *NewParmSI = IR.TransformType(Parm->getTypeSourceInfo());
  Parm->setType(NewParmSI->getType());
  Parm->setTypeSourceInfo(NewParmSI);
};

if (PatternDecl->isDefaulted()) {
  RebuildTypeSourceInfoForDefaultSpecialMembers();
  SetDeclDefaulted(Function, PatternDecl->getLocation());
} else {
  MultiLevelTemplateArgumentList TemplateArgs = getTemplateInstantiationArgs(
      Function, /*Final=*/false, nullptr, false, PatternDecl);

  // Substitute into the qualifier; we can get a substitution failure here
  // through evil use of alias templates.
  // FIXME: Is CurContext correct for this? Should we go to the (instantiation
  // of the) lexical context of the pattern?
  SubstQualifier(*this, PatternDecl, Function, TemplateArgs);

  ActOnStartOfFunctionDef(nullptr, Function);

  // Enter the scope of this instantiation. We don't use
  // PushDeclContext because we don't have a scope.
  Sema::ContextRAII savedContext(*this, Function);

  if (addInstantiatedParametersToScope(Function, PatternDecl, Scope,
                                       TemplateArgs))
    return;

  StmtResult Body;
  if (PatternDecl->hasSkippedBody()) {
    ActOnSkippedFunctionBody(Function);
    Body = nullptr;
  } else {
    if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
      // If this is a constructor, instantiate the member initializers.
      InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
                                 TemplateArgs);

      // If this is an MS ABI dllexport default constructor, instantiate any
      // default arguments.
      if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
          Ctor->isDefaultConstructor()) {
        InstantiateDefaultCtorDefaultArgs(Ctor);
      }
    }

    // Instantiate the function body.
    Body = SubstStmt(Pattern, TemplateArgs);

    if (Body.isInvalid())
      Function->setInvalidDecl();
  }
  // FIXME: finishing the function body while in an expression evaluation
  // context seems wrong. Investigate more.
  ActOnFinishFunctionBody(Function, Body.get(), /*IsInstantiation=*/true);

  PerformDependentDiagnostics(PatternDecl, TemplateArgs);

  if (auto *Listener = getASTMutationListener())
    Listener->FunctionDefinitionInstantiated(Function);

  savedContext.pop();
}

DeclGroupRef DG(Function);
Consumer.HandleTopLevelDecl(DG);

// This class may have local implicit instantiations that need to be
// instantiation within this scope.
LocalInstantiations.perform();
Scope.Exit();
GlobalInstantiations.perform();
5125}

5127VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
  VarTemplateDecl *VarTemplate, VarDecl *FromVar,
  const TemplateArgumentList &TemplateArgList,
  const TemplateArgumentListInfo &TemplateArgsInfo,
  SmallVectorImpl<TemplateArgument> &Converted,
  SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs,
  LocalInstantiationScope *StartingScope) {
if (FromVar->isInvalidDecl())
  return nullptr;

InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
if (Inst.isInvalid())
  return nullptr;

// Instantiate the first declaration of the variable template: for a partial
// specialization of a static data member template, the first declaration may
// or may not be the declaration in the class; if it's in the class, we want
// to instantiate a member in the class (a declaration), and if it's outside,
// we want to instantiate a definition.
//
// If we're instantiating an explicitly-specialized member template or member
// partial specialization, don't do this. The member specialization completely
// replaces the original declaration in this case.
bool IsMemberSpec = false;
MultiLevelTemplateArgumentList MultiLevelList;
if (auto *PartialSpec =
        dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar)) {
  IsMemberSpec = PartialSpec->isMemberSpecialization();
  MultiLevelList.addOuterTemplateArguments(
      PartialSpec, TemplateArgList.asArray(), /*Final=*/false);
} else {
  assert(VarTemplate == FromVar->getDescribedVarTemplate())(static_cast <bool> (VarTemplate == FromVar->getDescribedVarTemplate
()) ? void (0) : __assert_fail ("VarTemplate == FromVar->getDescribedVarTemplate()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5158, __extension__
 __PRETTY_FUNCTION__));
  IsMemberSpec = VarTemplate->isMemberSpecialization();
  MultiLevelList.addOuterTemplateArguments(
      VarTemplate, TemplateArgList.asArray(), /*Final=*/false);
}
if (!IsMemberSpec)
  FromVar = FromVar->getFirstDecl();

TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
                                      MultiLevelList);

// TODO: Set LateAttrs and StartingScope ...

return cast_or_null<VarTemplateSpecializationDecl>(
    Instantiator.VisitVarTemplateSpecializationDecl(
        VarTemplate, FromVar, TemplateArgsInfo, Converted));
5174}

5176/// Instantiates a variable template specialization by completing it
5177/// with appropriate type information and initializer.
5178VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
  VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
  const MultiLevelTemplateArgumentList &TemplateArgs) {
assert(PatternDecl->isThisDeclarationADefinition() &&(static_cast <bool> (PatternDecl->isThisDeclarationADefinition
() && "don't have a definition to instantiate from") ?
 void (0) : __assert_fail ("PatternDecl->isThisDeclarationADefinition() && \"don't have a definition to instantiate from\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5182, __extension__
 __PRETTY_FUNCTION__))
       "don't have a definition to instantiate from")(static_cast <bool> (PatternDecl->isThisDeclarationADefinition
() && "don't have a definition to instantiate from") ?
 void (0) : __assert_fail ("PatternDecl->isThisDeclarationADefinition() && \"don't have a definition to instantiate from\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5182, __extension__
 __PRETTY_FUNCTION__));

// Do substitution on the type of the declaration
TypeSourceInfo *DI =
    SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
              PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
if (!DI)
  return nullptr;

// Update the type of this variable template specialization.
VarSpec->setType(DI->getType());

// Convert the declaration into a definition now.
VarSpec->setCompleteDefinition();

// Instantiate the initializer.
InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);

if (getLangOpts().OpenCL)
  deduceOpenCLAddressSpace(VarSpec);

return VarSpec;
5204}

5206/// BuildVariableInstantiation - Used after a new variable has been created.
5207/// Sets basic variable data and decides whether to postpone the
5208/// variable instantiation.
5209void Sema::BuildVariableInstantiation(
  VarDecl *NewVar, VarDecl *OldVar,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
  LocalInstantiationScope *StartingScope,
  bool InstantiatingVarTemplate,
  VarTemplateSpecializationDecl *PrevDeclForVarTemplateSpecialization) {
// Instantiating a partial specialization to produce a partial
// specialization.
bool InstantiatingVarTemplatePartialSpec =
    isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
    isa<VarTemplatePartialSpecializationDecl>(NewVar);
// Instantiating from a variable template (or partial specialization) to
// produce a variable template specialization.
bool InstantiatingSpecFromTemplate =
    isa<VarTemplateSpecializationDecl>(NewVar) &&
    (OldVar->getDescribedVarTemplate() ||
     isa<VarTemplatePartialSpecializationDecl>(OldVar));

// If we are instantiating a local extern declaration, the
// instantiation belongs lexically to the containing function.
// If we are instantiating a static data member defined
// out-of-line, the instantiation will have the same lexical
// context (which will be a namespace scope) as the template.
if (OldVar->isLocalExternDecl()) {
  NewVar->setLocalExternDecl();
  NewVar->setLexicalDeclContext(Owner);
} else if (OldVar->isOutOfLine())
  NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
NewVar->setTSCSpec(OldVar->getTSCSpec());
NewVar->setInitStyle(OldVar->getInitStyle());
NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
NewVar->setObjCForDecl(OldVar->isObjCForDecl());
NewVar->setConstexpr(OldVar->isConstexpr());
NewVar->setInitCapture(OldVar->isInitCapture());
NewVar->setPreviousDeclInSameBlockScope(
    OldVar->isPreviousDeclInSameBlockScope());
NewVar->setAccess(OldVar->getAccess());

if (!OldVar->isStaticDataMember()) {
  if (OldVar->isUsed(false))
    NewVar->setIsUsed();
  NewVar->setReferenced(OldVar->isReferenced());
}

InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);

LookupResult Previous(
    *this, NewVar->getDeclName(), NewVar->getLocation(),
    NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
                                : Sema::LookupOrdinaryName,
    NewVar->isLocalExternDecl() ? Sema::ForExternalRedeclaration
                                : forRedeclarationInCurContext());

if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
    (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
     OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
  // We have a previous declaration. Use that one, so we merge with the
  // right type.
  if (NamedDecl *NewPrev = FindInstantiatedDecl(
          NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
    Previous.addDecl(NewPrev);
} else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
           OldVar->hasLinkage()) {
  LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
} else if (PrevDeclForVarTemplateSpecialization) {
  Previous.addDecl(PrevDeclForVarTemplateSpecialization);
}
CheckVariableDeclaration(NewVar, Previous);

if (!InstantiatingVarTemplate) {
  NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
  if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
    NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
}

if (!OldVar->isOutOfLine()) {
  if (NewVar->getDeclContext()->isFunctionOrMethod())
    CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
}

// Link instantiations of static data members back to the template from
// which they were instantiated.
//
// Don't do this when instantiating a template (we link the template itself
// back in that case) nor when instantiating a static data member template
// (that's not a member specialization).
if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate &&
    !InstantiatingSpecFromTemplate)
  NewVar->setInstantiationOfStaticDataMember(OldVar,
                                             TSK_ImplicitInstantiation);

// If the pattern is an (in-class) explicit specialization, then the result
// is also an explicit specialization.
if (VarTemplateSpecializationDecl *OldVTSD =
        dyn_cast<VarTemplateSpecializationDecl>(OldVar)) {
  if (OldVTSD->getSpecializationKind() == TSK_ExplicitSpecialization &&
      !isa<VarTemplatePartialSpecializationDecl>(OldVTSD))
    cast<VarTemplateSpecializationDecl>(NewVar)->setSpecializationKind(
        TSK_ExplicitSpecialization);
}

// Forward the mangling number from the template to the instantiated decl.
Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));

// Figure out whether to eagerly instantiate the initializer.
if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
  // We're producing a template. Don't instantiate the initializer yet.
} else if (NewVar->getType()->isUndeducedType()) {
  // We need the type to complete the declaration of the variable.
  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
} else if (InstantiatingSpecFromTemplate ||
           (OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
            !NewVar->isThisDeclarationADefinition())) {
  // Delay instantiation of the initializer for variable template
  // specializations or inline static data members until a definition of the
  // variable is needed.
} else {
  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
}

// Diagnose unused local variables with dependent types, where the diagnostic
// will have been deferred.
if (!NewVar->isInvalidDecl() &&
    NewVar->getDeclContext()->isFunctionOrMethod() &&
    OldVar->getType()->isDependentType())
  DiagnoseUnusedDecl(NewVar);
5337}

5339/// Instantiate the initializer of a variable.
5340void Sema::InstantiateVariableInitializer(
  VarDecl *Var, VarDecl *OldVar,
  const MultiLevelTemplateArgumentList &TemplateArgs) {
if (ASTMutationListener *L = getASTContext().getASTMutationListener())
  L->VariableDefinitionInstantiated(Var);

// We propagate the 'inline' flag with the initializer, because it
// would otherwise imply that the variable is a definition for a
// non-static data member.
if (OldVar->isInlineSpecified())
  Var->setInlineSpecified();
else if (OldVar->isInline())
  Var->setImplicitlyInline();

if (OldVar->getInit()) {
  EnterExpressionEvaluationContext Evaluated(
      *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);

  // Instantiate the initializer.
  ExprResult Init;

  {
    ContextRAII SwitchContext(*this, Var->getDeclContext());
    Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
                            OldVar->getInitStyle() == VarDecl::CallInit);
  }

  if (!Init.isInvalid()) {
    Expr *InitExpr = Init.get();

    if (Var->hasAttr<DLLImportAttr>() &&
        (!InitExpr ||
         !InitExpr->isConstantInitializer(getASTContext(), false))) {
      // Do not dynamically initialize dllimport variables.
    } else if (InitExpr) {
      bool DirectInit = OldVar->isDirectInit();
      AddInitializerToDecl(Var, InitExpr, DirectInit);
    } else
      ActOnUninitializedDecl(Var);
  } else {
    // FIXME: Not too happy about invalidating the declaration
    // because of a bogus initializer.
    Var->setInvalidDecl();
  }
} else {
  // `inline` variables are a definition and declaration all in one; we won't
  // pick up an initializer from anywhere else.
  if (Var->isStaticDataMember() && !Var->isInline()) {
    if (!Var->isOutOfLine())
      return;

    // If the declaration inside the class had an initializer, don't add
    // another one to the out-of-line definition.
    if (OldVar->getFirstDecl()->hasInit())
      return;
  }

  // We'll add an initializer to a for-range declaration later.
  if (Var->isCXXForRangeDecl() || Var->isObjCForDecl())
    return;

  ActOnUninitializedDecl(Var);
}

if (getLangOpts().CUDA)
  checkAllowedCUDAInitializer(Var);
5406}

5408/// Instantiate the definition of the given variable from its
5409/// template.
5410///
5411/// \param PointOfInstantiation the point at which the instantiation was
5412/// required. Note that this is not precisely a "point of instantiation"
5413/// for the variable, but it's close.
5414///
5415/// \param Var the already-instantiated declaration of a templated variable.
5416///
5417/// \param Recursive if true, recursively instantiates any functions that
5418/// are required by this instantiation.
5419///
5420/// \param DefinitionRequired if true, then we are performing an explicit
5421/// instantiation where a definition of the variable is required. Complain
5422/// if there is no such definition.
5423void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
                                       VarDecl *Var, bool Recursive,
                                    bool DefinitionRequired, bool AtEndOfTU) {
if (Var->isInvalidDecl())
  return;

// Never instantiate an explicitly-specialized entity.
TemplateSpecializationKind TSK =
    Var->getTemplateSpecializationKindForInstantiation();
if (TSK == TSK_ExplicitSpecialization)
  return;

// Find the pattern and the arguments to substitute into it.
VarDecl *PatternDecl = Var->getTemplateInstantiationPattern();
assert(PatternDecl && "no pattern for templated variable")(static_cast <bool> (PatternDecl && "no pattern for templated variable"
) ? void (0) : __assert_fail ("PatternDecl && \"no pattern for templated variable\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5437, __extension__
 __PRETTY_FUNCTION__));
MultiLevelTemplateArgumentList TemplateArgs =
    getTemplateInstantiationArgs(Var);

VarTemplateSpecializationDecl *VarSpec =
    dyn_cast<VarTemplateSpecializationDecl>(Var);
if (VarSpec) {
  // If this is a static data member template, there might be an
  // uninstantiated initializer on the declaration. If so, instantiate
  // it now.
  //
  // FIXME: This largely duplicates what we would do below. The difference
  // is that along this path we may instantiate an initializer from an
  // in-class declaration of the template and instantiate the definition
  // from a separate out-of-class definition.
  if (PatternDecl->isStaticDataMember() &&
      (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
      !Var->hasInit()) {
    // FIXME: Factor out the duplicated instantiation context setup/tear down
    // code here.
    InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
    if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
      return;
    PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
                                        "instantiating variable initializer");

    // The instantiation is visible here, even if it was first declared in an
    // unimported module.
    Var->setVisibleDespiteOwningModule();

    // If we're performing recursive template instantiation, create our own
    // queue of pending implicit instantiations that we will instantiate
    // later, while we're still within our own instantiation context.
    GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                       /*Enabled=*/Recursive);
    LocalInstantiationScope Local(*this);
    LocalEagerInstantiationScope LocalInstantiations(*this);

    // Enter the scope of this instantiation. We don't use
    // PushDeclContext because we don't have a scope.
    ContextRAII PreviousContext(*this, Var->getDeclContext());
    InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
    PreviousContext.pop();

    // This variable may have local implicit instantiations that need to be
    // instantiated within this scope.
    LocalInstantiations.perform();
    Local.Exit();
    GlobalInstantiations.perform();
  }
} else {
  assert(Var->isStaticDataMember() && PatternDecl->isStaticDataMember() &&(static_cast <bool> (Var->isStaticDataMember() &&
 PatternDecl->isStaticDataMember() && "not a static data member?"
) ? void (0) : __assert_fail ("Var->isStaticDataMember() && PatternDecl->isStaticDataMember() && \"not a static data member?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5489, __extension__
 __PRETTY_FUNCTION__))
         "not a static data member?")(static_cast <bool> (Var->isStaticDataMember() &&
 PatternDecl->isStaticDataMember() && "not a static data member?"
) ? void (0) : __assert_fail ("Var->isStaticDataMember() && PatternDecl->isStaticDataMember() && \"not a static data member?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5489, __extension__
 __PRETTY_FUNCTION__));
}

VarDecl *Def = PatternDecl->getDefinition(getASTContext());

// If we don't have a definition of the variable template, we won't perform
// any instantiation. Rather, we rely on the user to instantiate this
// definition (or provide a specialization for it) in another translation
// unit.
if (!Def && !DefinitionRequired) {
  if (TSK == TSK_ExplicitInstantiationDefinition) {
    PendingInstantiations.push_back(
      std::make_pair(Var, PointOfInstantiation));
  } else if (TSK == TSK_ImplicitInstantiation) {
    // Warn about missing definition at the end of translation unit.
    if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
        !getSourceManager().isInSystemHeader(PatternDecl->getBeginLoc())) {
      Diag(PointOfInstantiation, diag::warn_var_template_missing)
        << Var;
      Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
      if (getLangOpts().CPlusPlus11)
        Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
    }
    return;
  }
}

// FIXME: We need to track the instantiation stack in order to know which
// definitions should be visible within this instantiation.
// FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
                                   /*InstantiatedFromMember*/false,
                                   PatternDecl, Def, TSK,
                                   /*Complain*/DefinitionRequired))
  return;

// C++11 [temp.explicit]p10:
//   Except for inline functions, const variables of literal types, variables
//   of reference types, [...] explicit instantiation declarations
//   have the effect of suppressing the implicit instantiation of the entity
//   to which they refer.
//
// FIXME: That's not exactly the same as "might be usable in constant
// expressions", which only allows constexpr variables and const integral
// types, not arbitrary const literal types.
if (TSK == TSK_ExplicitInstantiationDeclaration &&
    !Var->mightBeUsableInConstantExpressions(getASTContext()))
  return;

// Make sure to pass the instantiated variable to the consumer at the end.
struct PassToConsumerRAII {
  ASTConsumer &Consumer;
  VarDecl *Var;

  PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
    : Consumer(Consumer), Var(Var) { }

  ~PassToConsumerRAII() {
    Consumer.HandleCXXStaticMemberVarInstantiation(Var);
  }
} PassToConsumerRAII(Consumer, Var);

// If we already have a definition, we're done.
if (VarDecl *Def = Var->getDefinition()) {
  // We may be explicitly instantiating something we've already implicitly
  // instantiated.
  Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
                                     PointOfInstantiation);
  return;
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
  return;
PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
                                    "instantiating variable definition");

// If we're performing recursive template instantiation, create our own
// queue of pending implicit instantiations that we will instantiate later,
// while we're still within our own instantiation context.
GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                   /*Enabled=*/Recursive);

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
ContextRAII PreviousContext(*this, Var->getDeclContext());
LocalInstantiationScope Local(*this);

LocalEagerInstantiationScope LocalInstantiations(*this);

VarDecl *OldVar = Var;
if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
  // We're instantiating an inline static data member whose definition was
  // provided inside the class.
  InstantiateVariableInitializer(Var, Def, TemplateArgs);
} else if (!VarSpec) {
  Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
                                        TemplateArgs));
} else if (Var->isStaticDataMember() &&
           Var->getLexicalDeclContext()->isRecord()) {
  // We need to instantiate the definition of a static data member template,
  // and all we have is the in-class declaration of it. Instantiate a separate
  // declaration of the definition.
  TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
                                        TemplateArgs);

  TemplateArgumentListInfo TemplateArgInfo;
  if (const ASTTemplateArgumentListInfo *ArgInfo =
          VarSpec->getTemplateArgsInfo()) {
    TemplateArgInfo.setLAngleLoc(ArgInfo->getLAngleLoc());
    TemplateArgInfo.setRAngleLoc(ArgInfo->getRAngleLoc());
    for (const TemplateArgumentLoc &Arg : ArgInfo->arguments())
      TemplateArgInfo.addArgument(Arg);
  }

  Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
      VarSpec->getSpecializedTemplate(), Def, TemplateArgInfo,
      VarSpec->getTemplateArgs().asArray(), VarSpec));
  if (Var) {
    llvm::PointerUnion<VarTemplateDecl *,
                       VarTemplatePartialSpecializationDecl *> PatternPtr =
        VarSpec->getSpecializedTemplateOrPartial();
    if (VarTemplatePartialSpecializationDecl *Partial =
        PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
      cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
          Partial, &VarSpec->getTemplateInstantiationArgs());

    // Attach the initializer.
    InstantiateVariableInitializer(Var, Def, TemplateArgs);
  }
} else
  // Complete the existing variable's definition with an appropriately
  // substituted type and initializer.
  Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);

PreviousContext.pop();

if (Var) {
  PassToConsumerRAII.Var = Var;
  Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
                                     OldVar->getPointOfInstantiation());
}

// This variable may have local implicit instantiations that need to be
// instantiated within this scope.
LocalInstantiations.perform();
Local.Exit();
GlobalInstantiations.perform();
5637}

5639void
5640Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
                               const CXXConstructorDecl *Tmpl,
                         const MultiLevelTemplateArgumentList &TemplateArgs) {

SmallVector<CXXCtorInitializer*, 4> NewInits;
bool AnyErrors = Tmpl->isInvalidDecl();

// Instantiate all the initializers.
for (const auto *Init : Tmpl->inits()) {
  // Only instantiate written initializers, let Sema re-construct implicit
  // ones.
  if (!Init->isWritten())
    continue;

  SourceLocation EllipsisLoc;

  if (Init->isPackExpansion()) {
    // This is a pack expansion. We should expand it now.
    TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
    SmallVector<UnexpandedParameterPack, 4> Unexpanded;
    collectUnexpandedParameterPacks(BaseTL, Unexpanded);
    collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions;
    if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
                                        BaseTL.getSourceRange(),
                                        Unexpanded,
                                        TemplateArgs, ShouldExpand,
                                        RetainExpansion,
                                        NumExpansions)) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }
    assert(ShouldExpand && "Partial instantiation of base initializer?")(static_cast <bool> (ShouldExpand && "Partial instantiation of base initializer?"
) ? void (0) : __assert_fail ("ShouldExpand && \"Partial instantiation of base initializer?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5675, __extension__
 __PRETTY_FUNCTION__));

    // Loop over all of the arguments in the argument pack(s),
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);

      // Instantiate the initializer.
      ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
                                             /*CXXDirectInit=*/true);
      if (TempInit.isInvalid()) {
        AnyErrors = true;
        break;
      }

      // Instantiate the base type.
      TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
                                            TemplateArgs,
                                            Init->getSourceLocation(),
                                            New->getDeclName());
      if (!BaseTInfo) {
        AnyErrors = true;
        break;
      }

      // Build the initializer.
      MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
                                                   BaseTInfo, TempInit.get(),
                                                   New->getParent(),
                                                   SourceLocation());
      if (NewInit.isInvalid()) {
        AnyErrors = true;
        break;
      }

      NewInits.push_back(NewInit.get());
    }

    continue;
  }

  // Instantiate the initializer.
  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
                                         /*CXXDirectInit=*/true);
  if (TempInit.isInvalid()) {
    AnyErrors = true;
    continue;
  }

  MemInitResult NewInit;
  if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
    TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
                                      TemplateArgs,
                                      Init->getSourceLocation(),
                                      New->getDeclName());
    if (!TInfo) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }

    if (Init->isBaseInitializer())
      NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
                                     New->getParent(), EllipsisLoc);
    else
      NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
                                cast<CXXRecordDecl>(CurContext->getParent()));
  } else if (Init->isMemberInitializer()) {
    FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
                                                   Init->getMemberLocation(),
                                                   Init->getMember(),
                                                   TemplateArgs));
    if (!Member) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }

    NewInit = BuildMemberInitializer(Member, TempInit.get(),
                                     Init->getSourceLocation());
  } else if (Init->isIndirectMemberInitializer()) {
    IndirectFieldDecl *IndirectMember =
       cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
                               Init->getMemberLocation(),
                               Init->getIndirectMember(), TemplateArgs));

    if (!IndirectMember) {
      AnyErrors = true;
      New->setInvalidDecl();
      continue;
    }

    NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
                                     Init->getSourceLocation());
  }

  if (NewInit.isInvalid()) {
    AnyErrors = true;
    New->setInvalidDecl();
  } else {
    NewInits.push_back(NewInit.get());
  }
}

// Assign all the initializers to the new constructor.
ActOnMemInitializers(New,
                     /*FIXME: ColonLoc */
                     SourceLocation(),
                     NewInits,
                     AnyErrors);
5784}

5786// TODO: this could be templated if the various decl types used the
5787// same method name.
5788static bool isInstantiationOf(ClassTemplateDecl *Pattern,
                            ClassTemplateDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberTemplate();
} while (Instance);

return false;
5799}

5801static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
                            FunctionTemplateDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberTemplate();
} while (Instance);

return false;
5812}

5814static bool
5815isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
                ClassTemplatePartialSpecializationDecl *Instance) {
Pattern
  = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
do {
  Instance = cast<ClassTemplatePartialSpecializationDecl>(
                                              Instance->getCanonicalDecl());
  if (Pattern == Instance)
    return true;
  Instance = Instance->getInstantiatedFromMember();
} while (Instance);

return false;
5828}

5830static bool isInstantiationOf(CXXRecordDecl *Pattern,
                            CXXRecordDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberClass();
} while (Instance);

return false;
5841}

5843static bool isInstantiationOf(FunctionDecl *Pattern,
                            FunctionDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberFunction();
} while (Instance);

return false;
5854}

5856static bool isInstantiationOf(EnumDecl *Pattern,
                            EnumDecl *Instance) {
Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromMemberEnum();
} while (Instance);

return false;
5867}

5869static bool isInstantiationOf(UsingShadowDecl *Pattern,
                            UsingShadowDecl *Instance,
                            ASTContext &C) {
return declaresSameEntity(C.getInstantiatedFromUsingShadowDecl(Instance),
                          Pattern);
5874}

5876static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
                            ASTContext &C) {
return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
5879}

5881template<typename T>
5882static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
                                               ASTContext &Ctx) {
// An unresolved using declaration can instantiate to an unresolved using
// declaration, or to a using declaration or a using declaration pack.
//
// Multiple declarations can claim to be instantiated from an unresolved
// using declaration if it's a pack expansion. We want the UsingPackDecl
// in that case, not the individual UsingDecls within the pack.
bool OtherIsPackExpansion;
NamedDecl *OtherFrom;
if (auto *OtherUUD = dyn_cast<T>(Other)) {
  OtherIsPackExpansion = OtherUUD->isPackExpansion();
  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
} else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
  OtherIsPackExpansion = true;
  OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
} else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
  OtherIsPackExpansion = false;
  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
} else {
  return false;
}
return Pattern->isPackExpansion() == OtherIsPackExpansion &&
       declaresSameEntity(OtherFrom, Pattern);
5906}

5908static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
                                            VarDecl *Instance) {
assert(Instance->isStaticDataMember())(static_cast <bool> (Instance->isStaticDataMember())
 ? void (0) : __assert_fail ("Instance->isStaticDataMember()"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 5910, __extension__
 __PRETTY_FUNCTION__));

Pattern = Pattern->getCanonicalDecl();

do {
  Instance = Instance->getCanonicalDecl();
  if (Pattern == Instance) return true;
  Instance = Instance->getInstantiatedFromStaticDataMember();
} while (Instance);

return false;
5921}

5923// Other is the prospective instantiation
5924// D is the prospective pattern
5925static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);

if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);

if (D->getKind() != Other->getKind())
  return false;

if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
  return isInstantiationOf(cast<CXXRecordDecl>(D), Record);

if (auto *Function = dyn_cast<FunctionDecl>(Other))
  return isInstantiationOf(cast<FunctionDecl>(D), Function);

if (auto *Enum = dyn_cast<EnumDecl>(Other))
  return isInstantiationOf(cast<EnumDecl>(D), Enum);

if (auto *Var = dyn_cast<VarDecl>(Other))
  if (Var->isStaticDataMember())
    return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);

if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
  return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);

if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
  return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);

if (auto *PartialSpec =
        dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
  return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
                           PartialSpec);

if (auto *Field = dyn_cast<FieldDecl>(Other)) {
  if (!Field->getDeclName()) {
    // This is an unnamed field.
    return declaresSameEntity(Ctx.getInstantiatedFromUnnamedFieldDecl(Field),
                              cast<FieldDecl>(D));
  }
}

if (auto *Using = dyn_cast<UsingDecl>(Other))
  return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);

if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
  return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);

return D->getDeclName() &&
       D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
5975}

5977template<typename ForwardIterator>
5978static NamedDecl *findInstantiationOf(ASTContext &Ctx,
                                    NamedDecl *D,
                                    ForwardIterator first,
                                    ForwardIterator last) {
for (; first != last; ++first)
  if (isInstantiationOf(Ctx, D, *first))
    return cast<NamedDecl>(*first);

return nullptr;
5987}

5989/// Finds the instantiation of the given declaration context
5990/// within the current instantiation.
5991///
5992/// \returns NULL if there was an error
5993DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
                        const MultiLevelTemplateArgumentList &TemplateArgs) {
if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
  Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
  return cast_or_null<DeclContext>(ID);
} else return DC;
5999}

6001/// Determine whether the given context is dependent on template parameters at
6002/// level \p Level or below.
6003///
6004/// Sometimes we only substitute an inner set of template arguments and leave
6005/// the outer templates alone. In such cases, contexts dependent only on the
6006/// outer levels are not effectively dependent.
6007static bool isDependentContextAtLevel(DeclContext *DC, unsigned Level) {
if (!DC->isDependentContext())
  return false;
if (!Level)
  return true;
return cast<Decl>(DC)->getTemplateDepth() > Level;
6013}

6015/// Find the instantiation of the given declaration within the
6016/// current instantiation.
6017///
6018/// This routine is intended to be used when \p D is a declaration
6019/// referenced from within a template, that needs to mapped into the
6020/// corresponding declaration within an instantiation. For example,
6021/// given:
6022///
6023/// \code
6024/// template<typename T>
6025/// struct X {
6026///   enum Kind {
6027///     KnownValue = sizeof(T)
6028///   };
6029///
6030///   bool getKind() const { return KnownValue; }
6031/// };
6032///
6033/// template struct X<int>;
6034/// \endcode
6035///
6036/// In the instantiation of X<int>::getKind(), we need to map the \p
6037/// EnumConstantDecl for \p KnownValue (which refers to
6038/// X<T>::<Kind>::KnownValue) to its instantiation (X<int>::<Kind>::KnownValue).
6039/// \p FindInstantiatedDecl performs this mapping from within the instantiation
6040/// of X<int>.
6041NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        bool FindingInstantiatedContext) {
DeclContext *ParentDC = D->getDeclContext();
// Determine whether our parent context depends on any of the template
// arguments we're currently substituting.
bool ParentDependsOnArgs = isDependentContextAtLevel(
    ParentDC, TemplateArgs.getNumRetainedOuterLevels());
// FIXME: Parameters of pointer to functions (y below) that are themselves
// parameters (p below) can have their ParentDC set to the translation-unit
// - thus we can not consistently check if the ParentDC of such a parameter
// is Dependent or/and a FunctionOrMethod.
// For e.g. this code, during Template argument deduction tries to
// find an instantiated decl for (T y) when the ParentDC for y is
// the translation unit.
//   e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
//   float baz(float(*)()) { return 0.0; }
//   Foo(baz);
// The better fix here is perhaps to ensure that a ParmVarDecl, by the time
// it gets here, always has a FunctionOrMethod as its ParentDC??
// For now:
//  - as long as we have a ParmVarDecl whose parent is non-dependent and
//    whose type is not instantiation dependent, do nothing to the decl
//  - otherwise find its instantiated decl.
if (isa<ParmVarDecl>(D) && !ParentDependsOnArgs &&
    !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
  return D;
if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
    isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
    (ParentDependsOnArgs && (ParentDC->isFunctionOrMethod() ||
                             isa<OMPDeclareReductionDecl>(ParentDC) ||
                             isa<OMPDeclareMapperDecl>(ParentDC))) ||
    (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda() &&
     cast<CXXRecordDecl>(D)->getTemplateDepth() >
         TemplateArgs.getNumRetainedOuterLevels())) {
  // D is a local of some kind. Look into the map of local
  // declarations to their instantiations.
  if (CurrentInstantiationScope) {
    if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
      if (Decl *FD = Found->dyn_cast<Decl *>())
        return cast<NamedDecl>(FD);

      int PackIdx = ArgumentPackSubstitutionIndex;
      assert(PackIdx != -1 &&(static_cast <bool> (PackIdx != -1 && "found declaration pack but not pack expanding"
) ? void (0) : __assert_fail ("PackIdx != -1 && \"found declaration pack but not pack expanding\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6085, __extension__
 __PRETTY_FUNCTION__))
             "found declaration pack but not pack expanding")(static_cast <bool> (PackIdx != -1 && "found declaration pack but not pack expanding"
) ? void (0) : __assert_fail ("PackIdx != -1 && \"found declaration pack but not pack expanding\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6085, __extension__
 __PRETTY_FUNCTION__));
      typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
      return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
    }
  }

  // If we're performing a partial substitution during template argument
  // deduction, we may not have values for template parameters yet. They
  // just map to themselves.
  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
      isa<TemplateTemplateParmDecl>(D))
    return D;

  if (D->isInvalidDecl())
    return nullptr;

  // Normally this function only searches for already instantiated declaration
  // however we have to make an exclusion for local types used before
  // definition as in the code:
  //
  //   template<typename T> void f1() {
  //     void g1(struct x1);
  //     struct x1 {};
  //   }
  //
  // In this case instantiation of the type of 'g1' requires definition of
  // 'x1', which is defined later. Error recovery may produce an enum used
  // before definition. In these cases we need to instantiate relevant
  // declarations here.
  bool NeedInstantiate = false;
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
    NeedInstantiate = RD->isLocalClass();
  else if (isa<TypedefNameDecl>(D) &&
           isa<CXXDeductionGuideDecl>(D->getDeclContext()))
    NeedInstantiate = true;
  else
    NeedInstantiate = isa<EnumDecl>(D);
  if (NeedInstantiate) {
    Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
    CurrentInstantiationScope->InstantiatedLocal(D, Inst);
    return cast<TypeDecl>(Inst);
  }

  // If we didn't find the decl, then we must have a label decl that hasn't
  // been found yet.  Lazily instantiate it and return it now.
  assert(isa<LabelDecl>(D))(static_cast <bool> (isa<LabelDecl>(D)) ? void (0
) : __assert_fail ("isa<LabelDecl>(D)", "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 6130, __extension__ __PRETTY_FUNCTION__));

  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
  assert(Inst && "Failed to instantiate label??")(static_cast <bool> (Inst && "Failed to instantiate label??"
) ? void (0) : __assert_fail ("Inst && \"Failed to instantiate label??\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6133, __extension__
 __PRETTY_FUNCTION__));

  CurrentInstantiationScope->InstantiatedLocal(D, Inst);
  return cast<LabelDecl>(Inst);
}

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
  if (!Record->isDependentContext())
    return D;

  // Determine whether this record is the "templated" declaration describing
  // a class template or class template partial specialization.
  ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
  if (ClassTemplate)
    ClassTemplate = ClassTemplate->getCanonicalDecl();
  else if (ClassTemplatePartialSpecializationDecl *PartialSpec
             = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
    ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();

  // Walk the current context to find either the record or an instantiation of
  // it.
  DeclContext *DC = CurContext;
  while (!DC->isFileContext()) {
    // If we're performing substitution while we're inside the template
    // definition, we'll find our own context. We're done.
    if (DC->Equals(Record))
      return Record;

    if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
      // Check whether we're in the process of instantiating a class template
      // specialization of the template we're mapping.
      if (ClassTemplateSpecializationDecl *InstSpec
                    = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
        ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
        if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
          return InstRecord;
      }

      // Check whether we're in the process of instantiating a member class.
      if (isInstantiationOf(Record, InstRecord))
        return InstRecord;
    }

    // Move to the outer template scope.
    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
      if (FD->getFriendObjectKind() &&
          FD->getNonTransparentDeclContext()->isFileContext()) {
        DC = FD->getLexicalDeclContext();
        continue;
      }
      // An implicit deduction guide acts as if it's within the class template
      // specialization described by its name and first N template params.
      auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
      if (Guide && Guide->isImplicit()) {
        TemplateDecl *TD = Guide->getDeducedTemplate();
        // Convert the arguments to an "as-written" list.
        TemplateArgumentListInfo Args(Loc, Loc);
        for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
                                      TD->getTemplateParameters()->size())) {
          ArrayRef<TemplateArgument> Unpacked(Arg);
          if (Arg.getKind() == TemplateArgument::Pack)
            Unpacked = Arg.pack_elements();
          for (TemplateArgument UnpackedArg : Unpacked)
            Args.addArgument(
                getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
        }
        QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
        if (T.isNull())
          return nullptr;
        auto *SubstRecord = T->getAsCXXRecordDecl();
        assert(SubstRecord && "class template id not a class type?")(static_cast <bool> (SubstRecord && "class template id not a class type?"
) ? void (0) : __assert_fail ("SubstRecord && \"class template id not a class type?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6203, __extension__
 __PRETTY_FUNCTION__));
        // Check that this template-id names the primary template and not a
        // partial or explicit specialization. (In the latter cases, it's
        // meaningless to attempt to find an instantiation of D within the
        // specialization.)
        // FIXME: The standard doesn't say what should happen here.
        if (FindingInstantiatedContext &&
            usesPartialOrExplicitSpecialization(
                Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
          Diag(Loc, diag::err_specialization_not_primary_template)
            << T << (SubstRecord->getTemplateSpecializationKind() ==
                         TSK_ExplicitSpecialization);
          return nullptr;
        }
        DC = SubstRecord;
        continue;
      }
    }

    DC = DC->getParent();
  }

  // Fall through to deal with other dependent record types (e.g.,
  // anonymous unions in class templates).
}

if (!ParentDependsOnArgs)
  return D;

ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
if (!ParentDC)
  return nullptr;

if (ParentDC != D->getDeclContext()) {
  // We performed some kind of instantiation in the parent context,
  // so now we need to look into the instantiated parent context to
  // find the instantiation of the declaration D.

  // If our context used to be dependent, we may need to instantiate
  // it before performing lookup into that context.
  bool IsBeingInstantiated = false;
  if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
    if (!Spec->isDependentContext()) {
      QualType T = Context.getTypeDeclType(Spec);
      const RecordType *Tag = T->getAs<RecordType>();
      assert(Tag && "type of non-dependent record is not a RecordType")(static_cast <bool> (Tag && "type of non-dependent record is not a RecordType"
) ? void (0) : __assert_fail ("Tag && \"type of non-dependent record is not a RecordType\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6248, __extension__
 __PRETTY_FUNCTION__));
      if (Tag->isBeingDefined())
        IsBeingInstantiated = true;
      if (!Tag->isBeingDefined() &&
          RequireCompleteType(Loc, T, diag::err_incomplete_type))
        return nullptr;

      ParentDC = Tag->getDecl();
    }
  }

  NamedDecl *Result = nullptr;
  // FIXME: If the name is a dependent name, this lookup won't necessarily
  // find it. Does that ever matter?
  if (auto Name = D->getDeclName()) {
    DeclarationNameInfo NameInfo(Name, D->getLocation());
    DeclarationNameInfo NewNameInfo =
        SubstDeclarationNameInfo(NameInfo, TemplateArgs);
    Name = NewNameInfo.getName();
    if (!Name)
      return nullptr;
    DeclContext::lookup_result Found = ParentDC->lookup(Name);

    Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
  } else {
    // Since we don't have a name for the entity we're looking for,
    // our only option is to walk through all of the declarations to
    // find that name. This will occur in a few cases:
    //
    //   - anonymous struct/union within a template
    //   - unnamed class/struct/union/enum within a template
    //
    // FIXME: Find a better way to find these instantiations!
    Result = findInstantiationOf(Context, D,
                                 ParentDC->decls_begin(),
                                 ParentDC->decls_end());
  }

  if (!Result) {
    if (isa<UsingShadowDecl>(D)) {
      // UsingShadowDecls can instantiate to nothing because of using hiding.
    } else if (hasUncompilableErrorOccurred()) {
      // We've already complained about some ill-formed code, so most likely
      // this declaration failed to instantiate. There's no point in
      // complaining further, since this is normal in invalid code.
      // FIXME: Use more fine-grained 'invalid' tracking for this.
    } else if (IsBeingInstantiated) {
      // The class in which this member exists is currently being
      // instantiated, and we haven't gotten around to instantiating this
      // member yet. This can happen when the code uses forward declarations
      // of member classes, and introduces ordering dependencies via
      // template instantiation.
      Diag(Loc, diag::err_member_not_yet_instantiated)
        << D->getDeclName()
        << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
      Diag(D->getLocation(), diag::note_non_instantiated_member_here);
    } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
      // This enumeration constant was found when the template was defined,
      // but can't be found in the instantiation. This can happen if an
      // unscoped enumeration member is explicitly specialized.
      EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
      EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
                                                           TemplateArgs));
      assert(Spec->getTemplateSpecializationKind() ==(static_cast <bool> (Spec->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization) ? void (0) : __assert_fail (
"Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6312, __extension__
 __PRETTY_FUNCTION__))
               TSK_ExplicitSpecialization)(static_cast <bool> (Spec->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization) ? void (0) : __assert_fail (
"Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6312, __extension__
 __PRETTY_FUNCTION__));
      Diag(Loc, diag::err_enumerator_does_not_exist)
        << D->getDeclName()
        << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
      Diag(Spec->getLocation(), diag::note_enum_specialized_here)
        << Context.getTypeDeclType(Spec);
    } else {
      // We should have found something, but didn't.
      llvm_unreachable("Unable to find instantiation of declaration!")::llvm::llvm_unreachable_internal("Unable to find instantiation of declaration!"
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6320);
    }
  }

  D = Result;
}

return D;
6328}

6330/// Performs template instantiation for all implicit template
6331/// instantiations we have seen until this point.
6332void Sema::PerformPendingInstantiations(bool LocalOnly) {
std::deque<PendingImplicitInstantiation> delayedPCHInstantiations;
while (!PendingLocalImplicitInstantiations.empty() ||
       (!LocalOnly && !PendingInstantiations.empty())) {
  PendingImplicitInstantiation Inst;

  if (PendingLocalImplicitInstantiations.empty()) {
    Inst = PendingInstantiations.front();
    PendingInstantiations.pop_front();
  } else {
    Inst = PendingLocalImplicitInstantiations.front();
    PendingLocalImplicitInstantiations.pop_front();
  }

  // Instantiate function definitions
  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
    bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
                              TSK_ExplicitInstantiationDefinition;
    if (Function->isMultiVersion()) {
      getASTContext().forEachMultiversionedFunctionVersion(
          Function, [this, Inst, DefinitionRequired](FunctionDecl *CurFD) {
            InstantiateFunctionDefinition(/*FIXME:*/ Inst.second, CurFD, true,
                                          DefinitionRequired, true);
            if (CurFD->isDefined())
              CurFD->setInstantiationIsPending(false);
          });
    } else {
      InstantiateFunctionDefinition(/*FIXME:*/ Inst.second, Function, true,
                                    DefinitionRequired, true);
      if (Function->isDefined())
        Function->setInstantiationIsPending(false);
    }
    // Definition of a PCH-ed template declaration may be available only in the TU.
    if (!LocalOnly && LangOpts.PCHInstantiateTemplates &&
        TUKind == TU_Prefix && Function->instantiationIsPending())
      delayedPCHInstantiations.push_back(Inst);
    continue;
  }

  // Instantiate variable definitions
  VarDecl *Var = cast<VarDecl>(Inst.first);

  assert((Var->isStaticDataMember() ||(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6377, __extension__
 __PRETTY_FUNCTION__))
          isa<VarTemplateSpecializationDecl>(Var)) &&(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6377, __extension__
 __PRETTY_FUNCTION__))
         "Not a static data member, nor a variable template"(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6377, __extension__
 __PRETTY_FUNCTION__))
         " specialization?")(static_cast <bool> ((Var->isStaticDataMember() || isa
<VarTemplateSpecializationDecl>(Var)) && "Not a static data member, nor a variable template"
 " specialization?") ? void (0) : __assert_fail ("(Var->isStaticDataMember() || isa<VarTemplateSpecializationDecl>(Var)) && \"Not a static data member, nor a variable template\" \" specialization?\""
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6377, __extension__
 __PRETTY_FUNCTION__));

  // Don't try to instantiate declarations if the most recent redeclaration
  // is invalid.
  if (Var->getMostRecentDecl()->isInvalidDecl())
    continue;

  // Check if the most recent declaration has changed the specialization kind
  // and removed the need for implicit instantiation.
  switch (Var->getMostRecentDecl()
              ->getTemplateSpecializationKindForInstantiation()) {
  case TSK_Undeclared:
    llvm_unreachable("Cannot instantitiate an undeclared specialization.")::llvm::llvm_unreachable_internal("Cannot instantitiate an undeclared specialization."
, "clang/lib/Sema/SemaTemplateInstantiateDecl.cpp", 6389);
  case TSK_ExplicitInstantiationDeclaration:
  case TSK_ExplicitSpecialization:
    continue;  // No longer need to instantiate this type.
  case TSK_ExplicitInstantiationDefinition:
    // We only need an instantiation if the pending instantiation *is* the
    // explicit instantiation.
    if (Var != Var->getMostRecentDecl())
      continue;
    break;
  case TSK_ImplicitInstantiation:
    break;
  }

  PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
                                      "instantiating variable definition");
  bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
                            TSK_ExplicitInstantiationDefinition;

  // Instantiate static data member definitions or variable template
  // specializations.
  InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
                                DefinitionRequired, true);
}

if (!LocalOnly && LangOpts.PCHInstantiateTemplates)
  PendingInstantiations.swap(delayedPCHInstantiations);
6416}

6418void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
                     const MultiLevelTemplateArgumentList &TemplateArgs) {
for (auto *DD : Pattern->ddiags()) {
  switch (DD->getKind()) {
  case DependentDiagnostic::Access:
    HandleDependentAccessCheck(*DD, TemplateArgs);
    break;
  }
}
6427}

←

/build/source/clang/lib/Sema/TreeTransform.h

→

1//===------- TreeTransform.h - Semantic Tree Transformation -----*- 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//  This file implements a semantic tree transformation that takes a given
9//  AST and rebuilds it, possibly transforming some nodes in the process.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H

16#include "CoroutineStmtBuilder.h"
17#include "TypeLocBuilder.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/ExprConcepts.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/ExprOpenMP.h"
26#include "clang/AST/OpenMPClause.h"
27#include "clang/AST/Stmt.h"
28#include "clang/AST/StmtCXX.h"
29#include "clang/AST/StmtObjC.h"
30#include "clang/AST/StmtOpenMP.h"
31#include "clang/Basic/DiagnosticParse.h"
32#include "clang/Basic/OpenMPKinds.h"
33#include "clang/Sema/Designator.h"
34#include "clang/Sema/EnterExpressionEvaluationContext.h"
35#include "clang/Sema/Lookup.h"
36#include "clang/Sema/Ownership.h"
37#include "clang/Sema/ParsedTemplate.h"
38#include "clang/Sema/ScopeInfo.h"
39#include "clang/Sema/SemaDiagnostic.h"
40#include "clang/Sema/SemaInternal.h"
41#include "llvm/ADT/ArrayRef.h"
42#include "llvm/Support/ErrorHandling.h"
43#include <algorithm>
44#include <optional>

46using namespace llvm::omp;

48namespace clang {
49using namespace sema;

51/// A semantic tree transformation that allows one to transform one
52/// abstract syntax tree into another.
53///
54/// A new tree transformation is defined by creating a new subclass \c X of
55/// \c TreeTransform<X> and then overriding certain operations to provide
56/// behavior specific to that transformation. For example, template
57/// instantiation is implemented as a tree transformation where the
58/// transformation of TemplateTypeParmType nodes involves substituting the
59/// template arguments for their corresponding template parameters; a similar
60/// transformation is performed for non-type template parameters and
61/// template template parameters.
62///
63/// This tree-transformation template uses static polymorphism to allow
64/// subclasses to customize any of its operations. Thus, a subclass can
65/// override any of the transformation or rebuild operators by providing an
66/// operation with the same signature as the default implementation. The
67/// overriding function should not be virtual.
68///
69/// Semantic tree transformations are split into two stages, either of which
70/// can be replaced by a subclass. The "transform" step transforms an AST node
71/// or the parts of an AST node using the various transformation functions,
72/// then passes the pieces on to the "rebuild" step, which constructs a new AST
73/// node of the appropriate kind from the pieces. The default transformation
74/// routines recursively transform the operands to composite AST nodes (e.g.,
75/// the pointee type of a PointerType node) and, if any of those operand nodes
76/// were changed by the transformation, invokes the rebuild operation to create
77/// a new AST node.
78///
79/// Subclasses can customize the transformation at various levels. The
80/// most coarse-grained transformations involve replacing TransformType(),
81/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
82/// TransformTemplateName(), or TransformTemplateArgument() with entirely
83/// new implementations.
84///
85/// For more fine-grained transformations, subclasses can replace any of the
86/// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
87/// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
88/// replacing TransformTemplateTypeParmType() allows template instantiation
89/// to substitute template arguments for their corresponding template
90/// parameters. Additionally, subclasses can override the \c RebuildXXX
91/// functions to control how AST nodes are rebuilt when their operands change.
92/// By default, \c TreeTransform will invoke semantic analysis to rebuild
93/// AST nodes. However, certain other tree transformations (e.g, cloning) may
94/// be able to use more efficient rebuild steps.
95///
96/// There are a handful of other functions that can be overridden, allowing one
97/// to avoid traversing nodes that don't need any transformation
98/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
99/// operands have not changed (\c AlwaysRebuild()), and customize the
100/// default locations and entity names used for type-checking
101/// (\c getBaseLocation(), \c getBaseEntity()).
102template<typename Derived>
103class TreeTransform {
/// Private RAII object that helps us forget and then re-remember
/// the template argument corresponding to a partially-substituted parameter
/// pack.
class ForgetPartiallySubstitutedPackRAII {
  Derived &Self;
  TemplateArgument Old;

public:
  ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
    Old = Self.ForgetPartiallySubstitutedPack();
  }

  ~ForgetPartiallySubstitutedPackRAII() {
    Self.RememberPartiallySubstitutedPack(Old);
  }
};

121protected:
Sema &SemaRef;

/// The set of local declarations that have been transformed, for
/// cases where we are forced to build new declarations within the transformer
/// rather than in the subclass (e.g., lambda closure types).
llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;

129public:
/// Initializes a new tree transformer.
TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }

/// Retrieves a reference to the derived class.
Derived &getDerived() { return static_cast<Derived&>(*this); }

/// Retrieves a reference to the derived class.
const Derived &getDerived() const {
  return static_cast<const Derived&>(*this);
}

static inline ExprResult Owned(Expr *E) { return E; }
static inline StmtResult Owned(Stmt *S) { return S; }

/// Retrieves a reference to the semantic analysis object used for
/// this tree transform.
Sema &getSema() const { return SemaRef; }

/// Whether the transformation should always rebuild AST nodes, even
/// if none of the children have changed.
///
/// Subclasses may override this function to specify when the transformation
/// should rebuild all AST nodes.
///
/// We must always rebuild all AST nodes when performing variadic template
/// pack expansion, in order to avoid violating the AST invariant that each
/// statement node appears at most once in its containing declaration.
bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }

/// Whether the transformation is forming an expression or statement that
/// replaces the original. In this case, we'll reuse mangling numbers from
/// existing lambdas.
bool ReplacingOriginal() { return false; }

/// Wether CXXConstructExpr can be skipped when they are implicit.
/// They will be reconstructed when used if needed.
/// This is useful when the user that cause rebuilding of the
/// CXXConstructExpr is outside of the expression at which the TreeTransform
/// started.
bool AllowSkippingCXXConstructExpr() { return true; }

/// Returns the location of the entity being transformed, if that
/// information was not available elsewhere in the AST.
///
/// By default, returns no source-location information. Subclasses can
/// provide an alternative implementation that provides better location
/// information.
SourceLocation getBaseLocation() { return SourceLocation(); }

/// Returns the name of the entity being transformed, if that
/// information was not available elsewhere in the AST.
///
/// By default, returns an empty name. Subclasses can provide an alternative
/// implementation with a more precise name.
DeclarationName getBaseEntity() { return DeclarationName(); }

/// Sets the "base" location and entity when that
/// information is known based on another transformation.
///
/// By default, the source location and entity are ignored. Subclasses can
/// override this function to provide a customized implementation.
void setBase(SourceLocation Loc, DeclarationName Entity) { }

/// RAII object that temporarily sets the base location and entity
/// used for reporting diagnostics in types.
class TemporaryBase {
  TreeTransform &Self;
  SourceLocation OldLocation;
  DeclarationName OldEntity;

public:
  TemporaryBase(TreeTransform &Self, SourceLocation Location,
                DeclarationName Entity) : Self(Self) {
    OldLocation = Self.getDerived().getBaseLocation();
    OldEntity = Self.getDerived().getBaseEntity();

    if (Location.isValid())
      Self.getDerived().setBase(Location, Entity);
  }

  ~TemporaryBase() {
    Self.getDerived().setBase(OldLocation, OldEntity);
  }
};

/// Determine whether the given type \p T has already been
/// transformed.
///
/// Subclasses can provide an alternative implementation of this routine
/// to short-circuit evaluation when it is known that a given type will
/// not change. For example, template instantiation need not traverse
/// non-dependent types.
bool AlreadyTransformed(QualType T) {
  return T.isNull();
}

/// Transform a template parameter depth level.
///
/// During a transformation that transforms template parameters, this maps
/// an old template parameter depth to a new depth.
unsigned TransformTemplateDepth(unsigned Depth) {
  return Depth;
}

/// Determine whether the given call argument should be dropped, e.g.,
/// because it is a default argument.
///
/// Subclasses can provide an alternative implementation of this routine to
/// determine which kinds of call arguments get dropped. By default,
/// CXXDefaultArgument nodes are dropped (prior to transformation).
bool DropCallArgument(Expr *E) {
  return E->isDefaultArgument();
}

/// Determine whether we should expand a pack expansion with the
/// given set of parameter packs into separate arguments by repeatedly
/// transforming the pattern.
///
/// By default, the transformer never tries to expand pack expansions.
/// Subclasses can override this routine to provide different behavior.
///
/// \param EllipsisLoc The location of the ellipsis that identifies the
/// pack expansion.
///
/// \param PatternRange The source range that covers the entire pattern of
/// the pack expansion.
///
/// \param Unexpanded The set of unexpanded parameter packs within the
/// pattern.
///
/// \param ShouldExpand Will be set to \c true if the transformer should
/// expand the corresponding pack expansions into separate arguments. When
/// set, \c NumExpansions must also be set.
///
/// \param RetainExpansion Whether the caller should add an unexpanded
/// pack expansion after all of the expanded arguments. This is used
/// when extending explicitly-specified template argument packs per
/// C++0x [temp.arg.explicit]p9.
///
/// \param NumExpansions The number of separate arguments that will be in
/// the expanded form of the corresponding pack expansion. This is both an
/// input and an output parameter, which can be set by the caller if the
/// number of expansions is known a priori (e.g., due to a prior substitution)
/// and will be set by the callee when the number of expansions is known.
/// The callee must set this value when \c ShouldExpand is \c true; it may
/// set this value in other cases.
///
/// \returns true if an error occurred (e.g., because the parameter packs
/// are to be instantiated with arguments of different lengths), false
/// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
/// must be set.
bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
                             SourceRange PatternRange,
                             ArrayRef<UnexpandedParameterPack> Unexpanded,
                             bool &ShouldExpand, bool &RetainExpansion,
                             std::optional<unsigned> &NumExpansions) {
  ShouldExpand = false;
  return false;
}

/// "Forget" about the partially-substituted pack template argument,
/// when performing an instantiation that must preserve the parameter pack
/// use.
///
/// This routine is meant to be overridden by the template instantiator.
TemplateArgument ForgetPartiallySubstitutedPack() {
  return TemplateArgument();
}

/// "Remember" the partially-substituted pack template argument
/// after performing an instantiation that must preserve the parameter pack
/// use.
///
/// This routine is meant to be overridden by the template instantiator.
void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }

/// Note to the derived class when a function parameter pack is
/// being expanded.
void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }

/// Transforms the given type into another type.
///
/// By default, this routine transforms a type by creating a
/// TypeSourceInfo for it and delegating to the appropriate
/// function.  This is expensive, but we don't mind, because
/// this method is deprecated anyway;  all users should be
/// switched to storing TypeSourceInfos.
///
/// \returns the transformed type.
QualType TransformType(QualType T);

/// Transforms the given type-with-location into a new
/// type-with-location.
///
/// By default, this routine transforms a type by delegating to the
/// appropriate TransformXXXType to build a new type.  Subclasses
/// may override this function (to take over all type
/// transformations) or some set of the TransformXXXType functions
/// to alter the transformation.
TypeSourceInfo *TransformType(TypeSourceInfo *DI);

/// Transform the given type-with-location into a new
/// type, collecting location information in the given builder
/// as necessary.
///
QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);

/// Transform a type that is permitted to produce a
/// DeducedTemplateSpecializationType.
///
/// This is used in the (relatively rare) contexts where it is acceptable
/// for transformation to produce a class template type with deduced
/// template arguments.
/// @{
QualType TransformTypeWithDeducedTST(QualType T);
TypeSourceInfo *TransformTypeWithDeducedTST(TypeSourceInfo *DI);
/// @}

/// The reason why the value of a statement is not discarded, if any.
enum StmtDiscardKind {
  SDK_Discarded,
  SDK_NotDiscarded,
  SDK_StmtExprResult,
};

/// Transform the given statement.
///
/// By default, this routine transforms a statement by delegating to the
/// appropriate TransformXXXStmt function to transform a specific kind of
/// statement or the TransformExpr() function to transform an expression.
/// Subclasses may override this function to transform statements using some
/// other mechanism.
///
/// \returns the transformed statement.
StmtResult TransformStmt(Stmt *S, StmtDiscardKind SDK = SDK_Discarded);

/// Transform the given statement.
///
/// By default, this routine transforms a statement by delegating to the
/// appropriate TransformOMPXXXClause function to transform a specific kind
/// of clause. Subclasses may override this function to transform statements
/// using some other mechanism.
///
/// \returns the transformed OpenMP clause.
OMPClause *TransformOMPClause(OMPClause *S);

/// Transform the given attribute.
///
/// By default, this routine transforms a statement by delegating to the
/// appropriate TransformXXXAttr function to transform a specific kind
/// of attribute. Subclasses may override this function to transform
/// attributed statements/types using some other mechanism.
///
/// \returns the transformed attribute
const Attr *TransformAttr(const Attr *S);

// Transform the given statement attribute.
//
// Delegates to the appropriate TransformXXXAttr function to transform a
// specific kind of statement attribute. Unlike the non-statement taking
// version of this, this implements all attributes, not just pragmas.
const Attr *TransformStmtAttr(const Stmt *OrigS, const Stmt *InstS,
                              const Attr *A);

// Transform the specified attribute.
//
// Subclasses should override the transformation of attributes with a pragma
// spelling to transform expressions stored within the attribute.
//
// \returns the transformed attribute.
400#define ATTR(X)                                                                \
const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
402#include "clang/Basic/AttrList.inc"

// Transform the specified attribute.
//
// Subclasses should override the transformation of attributes to do
// transformation and checking of statement attributes. By default, this
// delegates to the non-statement taking version.
//
// \returns the transformed attribute.
411#define ATTR(X)                                                                \
const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *,            \
                                      const X##Attr *A) {                    \
  return getDerived().Transform##X##Attr(A);                                 \
}
416#include "clang/Basic/AttrList.inc"

/// Transform the given expression.
///
/// By default, this routine transforms an expression by delegating to the
/// appropriate TransformXXXExpr function to build a new expression.
/// Subclasses may override this function to transform expressions using some
/// other mechanism.
///
/// \returns the transformed expression.
ExprResult TransformExpr(Expr *E);

/// Transform the given initializer.
///
/// By default, this routine transforms an initializer by stripping off the
/// semantic nodes added by initialization, then passing the result to
/// TransformExpr or TransformExprs.
///
/// \returns the transformed initializer.
ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);

/// Transform the given list of expressions.
///
/// This routine transforms a list of expressions by invoking
/// \c TransformExpr() for each subexpression. However, it also provides
/// support for variadic templates by expanding any pack expansions (if the
/// derived class permits such expansion) along the way. When pack expansions
/// are present, the number of outputs may not equal the number of inputs.
///
/// \param Inputs The set of expressions to be transformed.
///
/// \param NumInputs The number of expressions in \c Inputs.
///
/// \param IsCall If \c true, then this transform is being performed on
/// function-call arguments, and any arguments that should be dropped, will
/// be.
///
/// \param Outputs The transformed input expressions will be added to this
/// vector.
///
/// \param ArgChanged If non-NULL, will be set \c true if any argument changed
/// due to transformation.
///
/// \returns true if an error occurred, false otherwise.
bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
                    SmallVectorImpl<Expr *> &Outputs,
                    bool *ArgChanged = nullptr);

/// Transform the given declaration, which is referenced from a type
/// or expression.
///
/// By default, acts as the identity function on declarations, unless the
/// transformer has had to transform the declaration itself. Subclasses
/// may override this function to provide alternate behavior.
Decl *TransformDecl(SourceLocation Loc, Decl *D) {
  llvm::DenseMap<Decl *, Decl *>::iterator Known
    = TransformedLocalDecls.find(D);
  if (Known != TransformedLocalDecls.end())
    return Known->second;

  return D;
}

/// Transform the specified condition.
///
/// By default, this transforms the variable and expression and rebuilds
/// the condition.
Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
                                         Expr *Expr,
                                         Sema::ConditionKind Kind);

/// Transform the attributes associated with the given declaration and
/// place them on the new declaration.
///
/// By default, this operation does nothing. Subclasses may override this
/// behavior to transform attributes.
void transformAttrs(Decl *Old, Decl *New) { }

/// Note that a local declaration has been transformed by this
/// transformer.
///
/// Local declarations are typically transformed via a call to
/// TransformDefinition. However, in some cases (e.g., lambda expressions),
/// the transformer itself has to transform the declarations. This routine
/// can be overridden by a subclass that keeps track of such mappings.
void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> New) {
  assert(New.size() == 1 &&(static_cast <bool> (New.size() == 1 && "must override transformedLocalDecl if performing pack expansion"
) ? void (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 503, __extension__ __PRETTY_FUNCTION__
))
         "must override transformedLocalDecl if performing pack expansion")(static_cast <bool> (New.size() == 1 && "must override transformedLocalDecl if performing pack expansion"
) ? void (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 503, __extension__ __PRETTY_FUNCTION__
));
  TransformedLocalDecls[Old] = New.front();
}

/// Transform the definition of the given declaration.
///
/// By default, invokes TransformDecl() to transform the declaration.
/// Subclasses may override this function to provide alternate behavior.
Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
  return getDerived().TransformDecl(Loc, D);
}

/// Transform the given declaration, which was the first part of a
/// nested-name-specifier in a member access expression.
///
/// This specific declaration transformation only applies to the first
/// identifier in a nested-name-specifier of a member access expression, e.g.,
/// the \c T in \c x->T::member
///
/// By default, invokes TransformDecl() to transform the declaration.
/// Subclasses may override this function to provide alternate behavior.
NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
  return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
}

/// Transform the set of declarations in an OverloadExpr.
bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
                                LookupResult &R);

/// Transform the given nested-name-specifier with source-location
/// information.
///
/// By default, transforms all of the types and declarations within the
/// nested-name-specifier. Subclasses may override this function to provide
/// alternate behavior.
NestedNameSpecifierLoc
TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
                                QualType ObjectType = QualType(),
                                NamedDecl *FirstQualifierInScope = nullptr);

/// Transform the given declaration name.
///
/// By default, transforms the types of conversion function, constructor,
/// and destructor names and then (if needed) rebuilds the declaration name.
/// Identifiers and selectors are returned unmodified. Subclasses may
/// override this function to provide alternate behavior.
DeclarationNameInfo
TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);

bool TransformRequiresExprRequirements(ArrayRef<concepts::Requirement *> Reqs,
    llvm::SmallVectorImpl<concepts::Requirement *> &Transformed);
concepts::TypeRequirement *
TransformTypeRequirement(concepts::TypeRequirement *Req);
concepts::ExprRequirement *
TransformExprRequirement(concepts::ExprRequirement *Req);
concepts::NestedRequirement *
TransformNestedRequirement(concepts::NestedRequirement *Req);

/// Transform the given template name.
///
/// \param SS The nested-name-specifier that qualifies the template
/// name. This nested-name-specifier must already have been transformed.
///
/// \param Name The template name to transform.
///
/// \param NameLoc The source location of the template name.
///
/// \param ObjectType If we're translating a template name within a member
/// access expression, this is the type of the object whose member template
/// is being referenced.
///
/// \param FirstQualifierInScope If the first part of a nested-name-specifier
/// also refers to a name within the current (lexical) scope, this is the
/// declaration it refers to.
///
/// By default, transforms the template name by transforming the declarations
/// and nested-name-specifiers that occur within the template name.
/// Subclasses may override this function to provide alternate behavior.
TemplateName
TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
                      SourceLocation NameLoc,
                      QualType ObjectType = QualType(),
                      NamedDecl *FirstQualifierInScope = nullptr,
                      bool AllowInjectedClassName = false);

/// Transform the given template argument.
///
/// By default, this operation transforms the type, expression, or
/// declaration stored within the template argument and constructs a
/// new template argument from the transformed result. Subclasses may
/// override this function to provide alternate behavior.
///
/// Returns true if there was an error.
bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
                               TemplateArgumentLoc &Output,
                               bool Uneval = false);

/// Transform the given set of template arguments.
///
/// By default, this operation transforms all of the template arguments
/// in the input set using \c TransformTemplateArgument(), and appends
/// the transformed arguments to the output list.
///
/// Note that this overload of \c TransformTemplateArguments() is merely
/// a convenience function. Subclasses that wish to override this behavior
/// should override the iterator-based member template version.
///
/// \param Inputs The set of template arguments to be transformed.
///
/// \param NumInputs The number of template arguments in \p Inputs.
///
/// \param Outputs The set of transformed template arguments output by this
/// routine.
///
/// Returns true if an error occurred.
bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
                                unsigned NumInputs,
                                TemplateArgumentListInfo &Outputs,
                                bool Uneval = false) {
  return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
                                    Uneval);
}

/// Transform the given set of template arguments.
///
/// By default, this operation transforms all of the template arguments
/// in the input set using \c TransformTemplateArgument(), and appends
/// the transformed arguments to the output list.
///
/// \param First An iterator to the first template argument.
///
/// \param Last An iterator one step past the last template argument.
///
/// \param Outputs The set of transformed template arguments output by this
/// routine.
///
/// Returns true if an error occurred.
template<typename InputIterator>
bool TransformTemplateArguments(InputIterator First,
                                InputIterator Last,
                                TemplateArgumentListInfo &Outputs,
                                bool Uneval = false);

/// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
void InventTemplateArgumentLoc(const TemplateArgument &Arg,
                               TemplateArgumentLoc &ArgLoc);

/// Fakes up a TypeSourceInfo for a type.
TypeSourceInfo *InventTypeSourceInfo(QualType T) {
  return SemaRef.Context.getTrivialTypeSourceInfo(T,
                     getDerived().getBaseLocation());
}

656#define ABSTRACT_TYPELOC(CLASS, PARENT)
657#define TYPELOC(CLASS, PARENT)                                   \
QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
659#include "clang/AST/TypeLocNodes.def"

QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                       TemplateTypeParmTypeLoc TL,
                                       bool SuppressObjCLifetime);
QualType
TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmPackTypeLoc TL,
                                       bool SuppressObjCLifetime);

template<typename Fn>
QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
                                    FunctionProtoTypeLoc TL,
                                    CXXRecordDecl *ThisContext,
                                    Qualifiers ThisTypeQuals,
                                    Fn TransformExceptionSpec);

bool TransformExceptionSpec(SourceLocation Loc,
                            FunctionProtoType::ExceptionSpecInfo &ESI,
                            SmallVectorImpl<QualType> &Exceptions,
                            bool &Changed);

StmtResult TransformSEHHandler(Stmt *Handler);

QualType
TransformTemplateSpecializationType(TypeLocBuilder &TLB,
                                    TemplateSpecializationTypeLoc TL,
                                    TemplateName Template);

QualType
TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                                    DependentTemplateSpecializationTypeLoc TL,
                                             TemplateName Template,
                                             CXXScopeSpec &SS);

QualType TransformDependentTemplateSpecializationType(
    TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
    NestedNameSpecifierLoc QualifierLoc);

/// Transforms the parameters of a function type into the
/// given vectors.
///
/// The result vectors should be kept in sync; null entries in the
/// variables vector are acceptable.
///
/// LastParamTransformed, if non-null, will be set to the index of the last
/// parameter on which transfromation was started. In the event of an error,
/// this will contain the parameter which failed to instantiate.
///
/// Return true on error.
bool TransformFunctionTypeParams(
    SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
    const QualType *ParamTypes,
    const FunctionProtoType::ExtParameterInfo *ParamInfos,
    SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
    Sema::ExtParameterInfoBuilder &PInfos, unsigned *LastParamTransformed);

bool TransformFunctionTypeParams(
    SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
    const QualType *ParamTypes,
    const FunctionProtoType::ExtParameterInfo *ParamInfos,
    SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
    Sema::ExtParameterInfoBuilder &PInfos) {
  return getDerived().TransformFunctionTypeParams(
      Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos, nullptr);
}

/// Transforms the parameters of a requires expresison into the given vectors.
///
/// The result vectors should be kept in sync; null entries in the
/// variables vector are acceptable.
///
/// Returns an unset ExprResult on success.  Returns an ExprResult the 'not
/// satisfied' RequiresExpr if subsitution failed, OR an ExprError, both of
/// which are cases where transformation shouldn't continue.
ExprResult TransformRequiresTypeParams(
    SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE,
    RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params,
    SmallVectorImpl<QualType> &PTypes,
    SmallVectorImpl<ParmVarDecl *> &TransParams,
    Sema::ExtParameterInfoBuilder &PInfos) {
  if (getDerived().TransformFunctionTypeParams(
          KWLoc, Params, /*ParamTypes=*/nullptr,
          /*ParamInfos=*/nullptr, PTypes, &TransParams, PInfos))
    return ExprError();

  return ExprResult{};
}

/// Transforms a single function-type parameter.  Return null
/// on error.
///
/// \param indexAdjustment - A number to add to the parameter's
///   scope index;  can be negative
ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                        int indexAdjustment,
                                        std::optional<unsigned> NumExpansions,
                                        bool ExpectParameterPack);

/// Transform the body of a lambda-expression.
StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
/// Alternative implementation of TransformLambdaBody that skips transforming
/// the body.
StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);

QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);

StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);

TemplateParameterList *TransformTemplateParameterList(
      TemplateParameterList *TPL) {
  return TPL;
}

ExprResult TransformAddressOfOperand(Expr *E);

ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
                                              bool IsAddressOfOperand,
                                              TypeSourceInfo **RecoveryTSI);

ExprResult TransformParenDependentScopeDeclRefExpr(
    ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
    TypeSourceInfo **RecoveryTSI);

StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);

786// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
787// amount of stack usage with clang.
788#define STMT(Node, Parent)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
StmtResult Transform##Node(Node *S);
791#define VALUESTMT(Node, Parent)                   \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
794#define EXPR(Node, Parent)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
ExprResult Transform##Node(Node *E);
797#define ABSTRACT_STMT(Stmt)
798#include "clang/AST/StmtNodes.inc"

800#define GEN_CLANG_CLAUSE_CLASS
801#define CLAUSE_CLASS(Enum, Str, Class)                                         \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))                                                      \
OMPClause *Transform##Class(Class *S);
804#include "llvm/Frontend/OpenMP/OMP.inc"

/// Build a new qualified type given its unqualified type and type location.
///
/// By default, this routine adds type qualifiers only to types that can
/// have qualifiers, and silently suppresses those qualifiers that are not
/// permitted. Subclasses may override this routine to provide different
/// behavior.
QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);

/// Build a new pointer type given its pointee type.
///
/// By default, performs semantic analysis when building the pointer type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);

/// Build a new block pointer type given its pointee type.
///
/// By default, performs semantic analysis when building the block pointer
/// type. Subclasses may override this routine to provide different behavior.
QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);

/// Build a new reference type given the type it references.
///
/// By default, performs semantic analysis when building the
/// reference type. Subclasses may override this routine to provide
/// different behavior.
///
/// \param LValue whether the type was written with an lvalue sigil
/// or an rvalue sigil.
QualType RebuildReferenceType(QualType ReferentType,
                              bool LValue,
                              SourceLocation Sigil);

/// Build a new member pointer type given the pointee type and the
/// class type it refers into.
///
/// By default, performs semantic analysis when building the member pointer
/// type. Subclasses may override this routine to provide different behavior.
QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
                                  SourceLocation Sigil);

QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                                  SourceLocation ProtocolLAngleLoc,
                                  ArrayRef<ObjCProtocolDecl *> Protocols,
                                  ArrayRef<SourceLocation> ProtocolLocs,
                                  SourceLocation ProtocolRAngleLoc);

/// Build an Objective-C object type.
///
/// By default, performs semantic analysis when building the object type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildObjCObjectType(QualType BaseType,
                               SourceLocation Loc,
                               SourceLocation TypeArgsLAngleLoc,
                               ArrayRef<TypeSourceInfo *> TypeArgs,
                               SourceLocation TypeArgsRAngleLoc,
                               SourceLocation ProtocolLAngleLoc,
                               ArrayRef<ObjCProtocolDecl *> Protocols,
                               ArrayRef<SourceLocation> ProtocolLocs,
                               SourceLocation ProtocolRAngleLoc);

/// Build a new Objective-C object pointer type given the pointee type.
///
/// By default, directly builds the pointer type, with no additional semantic
/// analysis.
QualType RebuildObjCObjectPointerType(QualType PointeeType,
                                      SourceLocation Star);

/// Build a new array type given the element type, size
/// modifier, size of the array (if known), size expression, and index type
/// qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
/// Also by default, all of the other Rebuild*Array
QualType RebuildArrayType(QualType ElementType,
                          ArrayType::ArraySizeModifier SizeMod,
                          const llvm::APInt *Size,
                          Expr *SizeExpr,
                          unsigned IndexTypeQuals,
                          SourceRange BracketsRange);

/// Build a new constant array type given the element type, size
/// modifier, (known) size of the array, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildConstantArrayType(QualType ElementType,
                                  ArrayType::ArraySizeModifier SizeMod,
                                  const llvm::APInt &Size,
                                  Expr *SizeExpr,
                                  unsigned IndexTypeQuals,
                                  SourceRange BracketsRange);

/// Build a new incomplete array type given the element type, size
/// modifier, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildIncompleteArrayType(QualType ElementType,
                                    ArrayType::ArraySizeModifier SizeMod,
                                    unsigned IndexTypeQuals,
                                    SourceRange BracketsRange);

/// Build a new variable-length array type given the element type,
/// size modifier, size expression, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildVariableArrayType(QualType ElementType,
                                  ArrayType::ArraySizeModifier SizeMod,
                                  Expr *SizeExpr,
                                  unsigned IndexTypeQuals,
                                  SourceRange BracketsRange);

/// Build a new dependent-sized array type given the element type,
/// size modifier, size expression, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentSizedArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                        Expr *SizeExpr,
                                        unsigned IndexTypeQuals,
                                        SourceRange BracketsRange);

/// Build a new vector type given the element type and
/// number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
                           VectorType::VectorKind VecKind);

/// Build a new potentially dependently-sized extended vector type
/// given the element type and number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
                                         SourceLocation AttributeLoc,
                                         VectorType::VectorKind);

/// Build a new extended vector type given the element type and
/// number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
                              SourceLocation AttributeLoc);

/// Build a new potentially dependently-sized extended vector type
/// given the element type and number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentSizedExtVectorType(QualType ElementType,
                                            Expr *SizeExpr,
                                            SourceLocation AttributeLoc);

/// Build a new matrix type given the element type and dimensions.
QualType RebuildConstantMatrixType(QualType ElementType, unsigned NumRows,
                                   unsigned NumColumns);

/// Build a new matrix type given the type and dependently-defined
/// dimensions.
QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
                                         Expr *ColumnExpr,
                                         SourceLocation AttributeLoc);

/// Build a new DependentAddressSpaceType or return the pointee
/// type variable with the correct address space (retrieved from
/// AddrSpaceExpr) applied to it. The former will be returned in cases
/// where the address space remains dependent.
///
/// By default, performs semantic analysis when building the type with address
/// space applied. Subclasses may override this routine to provide different
/// behavior.
QualType RebuildDependentAddressSpaceType(QualType PointeeType,
                                          Expr *AddrSpaceExpr,
                                          SourceLocation AttributeLoc);

/// Build a new function type.
///
/// By default, performs semantic analysis when building the function type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildFunctionProtoType(QualType T,
                                  MutableArrayRef<QualType> ParamTypes,
                                  const FunctionProtoType::ExtProtoInfo &EPI);

/// Build a new unprototyped function type.
QualType RebuildFunctionNoProtoType(QualType ResultType);

/// Rebuild an unresolved typename type, given the decl that
/// the UnresolvedUsingTypenameDecl was transformed to.
QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);

/// Build a new type found via an alias.
QualType RebuildUsingType(UsingShadowDecl *Found, QualType Underlying) {
  return SemaRef.Context.getUsingType(Found, Underlying);
}

/// Build a new typedef type.
QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
  return SemaRef.Context.getTypeDeclType(Typedef);
}

/// Build a new MacroDefined type.
QualType RebuildMacroQualifiedType(QualType T,
                                   const IdentifierInfo *MacroII) {
  return SemaRef.Context.getMacroQualifiedType(T, MacroII);
}

/// Build a new class/struct/union type.
QualType RebuildRecordType(RecordDecl *Record) {
  return SemaRef.Context.getTypeDeclType(Record);
}

/// Build a new Enum type.
QualType RebuildEnumType(EnumDecl *Enum) {
  return SemaRef.Context.getTypeDeclType(Enum);
}

/// Build a new typeof(expr) type.
///
/// By default, performs semantic analysis when building the typeof type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc,
                               TypeOfKind Kind);

/// Build a new typeof(type) type.
///
/// By default, builds a new TypeOfType with the given underlying type.
QualType RebuildTypeOfType(QualType Underlying, TypeOfKind Kind);

/// Build a new unary transform type.
QualType RebuildUnaryTransformType(QualType BaseType,
                                   UnaryTransformType::UTTKind UKind,
                                   SourceLocation Loc);

/// Build a new C++11 decltype type.
///
/// By default, performs semantic analysis when building the decltype type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);

/// Build a new C++11 auto type.
///
/// By default, builds a new AutoType with the given deduced type.
QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword,
                         ConceptDecl *TypeConstraintConcept,
                         ArrayRef<TemplateArgument> TypeConstraintArgs) {
  // Note, IsDependent is always false here: we implicitly convert an 'auto'
  // which has been deduced to a dependent type into an undeduced 'auto', so
  // that we'll retry deduction after the transformation.
  return SemaRef.Context.getAutoType(Deduced, Keyword,
                                     /*IsDependent*/ false, /*IsPack=*/false,
                                     TypeConstraintConcept,
                                     TypeConstraintArgs);
}

/// By default, builds a new DeducedTemplateSpecializationType with the given
/// deduced type.
QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
    QualType Deduced) {
  return SemaRef.Context.getDeducedTemplateSpecializationType(
      Template, Deduced, /*IsDependent*/ false);
}

/// Build a new template specialization type.
///
/// By default, performs semantic analysis when building the template
/// specialization type. Subclasses may override this routine to provide
/// different behavior.
QualType RebuildTemplateSpecializationType(TemplateName Template,
                                           SourceLocation TemplateLoc,
                                           TemplateArgumentListInfo &Args);

/// Build a new parenthesized type.
///
/// By default, builds a new ParenType type from the inner type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildParenType(QualType InnerType) {
  return SemaRef.BuildParenType(InnerType);
}

/// Build a new qualified name type.
///
/// By default, builds a new ElaboratedType type from the keyword,
/// the nested-name-specifier and the named type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildElaboratedType(SourceLocation KeywordLoc,
                               ElaboratedTypeKeyword Keyword,
                               NestedNameSpecifierLoc QualifierLoc,
                               QualType Named) {
  return SemaRef.Context.getElaboratedType(Keyword,
                                       QualifierLoc.getNestedNameSpecifier(),
                                           Named);
}

/// Build a new typename type that refers to a template-id.
///
/// By default, builds a new DependentNameType type from the
/// nested-name-specifier and the given type. Subclasses may override
/// this routine to provide different behavior.
QualType RebuildDependentTemplateSpecializationType(
                                        ElaboratedTypeKeyword Keyword,
                                        NestedNameSpecifierLoc QualifierLoc,
                                        SourceLocation TemplateKWLoc,
                                        const IdentifierInfo *Name,
                                        SourceLocation NameLoc,
                                        TemplateArgumentListInfo &Args,
                                        bool AllowInjectedClassName) {
  // Rebuild the template name.
  // TODO: avoid TemplateName abstraction
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  TemplateName InstName = getDerived().RebuildTemplateName(
      SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
      AllowInjectedClassName);

  if (InstName.isNull())
    return QualType();

  // If it's still dependent, make a dependent specialization.
  if (InstName.getAsDependentTemplateName())
    return SemaRef.Context.getDependentTemplateSpecializationType(
        Keyword, QualifierLoc.getNestedNameSpecifier(), Name,
        Args.arguments());

  // Otherwise, make an elaborated type wrapping a non-dependent
  // specialization.
  QualType T =
      getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
  if (T.isNull())
    return QualType();
  return SemaRef.Context.getElaboratedType(
      Keyword, QualifierLoc.getNestedNameSpecifier(), T);
}

/// Build a new typename type that refers to an identifier.
///
/// By default, performs semantic analysis when building the typename type
/// (or elaborated type). Subclasses may override this routine to provide
/// different behavior.
QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
                                  SourceLocation KeywordLoc,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  const IdentifierInfo *Id,
                                  SourceLocation IdLoc,
                                  bool DeducedTSTContext) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
    // If the name is still dependent, just build a new dependent name type.
    if (!SemaRef.computeDeclContext(SS))
      return SemaRef.Context.getDependentNameType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                                  Id);
  }

  if (Keyword == ETK_None || Keyword == ETK_Typename) {
    return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
                                     *Id, IdLoc, DeducedTSTContext);
  }

  TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);

  // We had a dependent elaborated-type-specifier that has been transformed
  // into a non-dependent elaborated-type-specifier. Find the tag we're
  // referring to.
  LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
  DeclContext *DC = SemaRef.computeDeclContext(SS, false);
  if (!DC)
    return QualType();

  if (SemaRef.RequireCompleteDeclContext(SS, DC))
    return QualType();

  TagDecl *Tag = nullptr;
  SemaRef.LookupQualifiedName(Result, DC);
  switch (Result.getResultKind()) {
    case LookupResult::NotFound:
    case LookupResult::NotFoundInCurrentInstantiation:
      break;

    case LookupResult::Found:
      Tag = Result.getAsSingle<TagDecl>();
      break;

    case LookupResult::FoundOverloaded:
    case LookupResult::FoundUnresolvedValue:
      llvm_unreachable("Tag lookup cannot find non-tags")::llvm::llvm_unreachable_internal("Tag lookup cannot find non-tags"
, "clang/lib/Sema/TreeTransform.h", 1198);

    case LookupResult::Ambiguous:
      // Let the LookupResult structure handle ambiguities.
      return QualType();
  }

  if (!Tag) {
    // Check where the name exists but isn't a tag type and use that to emit
    // better diagnostics.
    LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
    SemaRef.LookupQualifiedName(Result, DC);
    switch (Result.getResultKind()) {
      case LookupResult::Found:
      case LookupResult::FoundOverloaded:
      case LookupResult::FoundUnresolvedValue: {
        NamedDecl *SomeDecl = Result.getRepresentativeDecl();
        Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
        SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
                                                             << NTK << Kind;
        SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
        break;
      }
      default:
        SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
            << Kind << Id << DC << QualifierLoc.getSourceRange();
        break;
    }
    return QualType();
  }

  if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
                                            IdLoc, Id)) {
    SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
    SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
    return QualType();
  }

  // Build the elaborated-type-specifier type.
  QualType T = SemaRef.Context.getTypeDeclType(Tag);
  return SemaRef.Context.getElaboratedType(Keyword,
                                       QualifierLoc.getNestedNameSpecifier(),
                                           T);
}

/// Build a new pack expansion type.
///
/// By default, builds a new PackExpansionType type from the given pattern.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange,
                                  SourceLocation EllipsisLoc,
                                  std::optional<unsigned> NumExpansions) {
  return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
                                      NumExpansions);
}

/// Build a new atomic type given its value type.
///
/// By default, performs semantic analysis when building the atomic type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);

/// Build a new pipe type given its value type.
QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
                         bool isReadPipe);

/// Build a bit-precise int given its value type.
QualType RebuildBitIntType(bool IsUnsigned, unsigned NumBits,
                           SourceLocation Loc);

/// Build a dependent bit-precise int given its value type.
QualType RebuildDependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr,
                                    SourceLocation Loc);

/// Build a new template name given a nested name specifier, a flag
/// indicating whether the "template" keyword was provided, and the template
/// that the template name refers to.
///
/// By default, builds the new template name directly. Subclasses may override
/// this routine to provide different behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 bool TemplateKW,
                                 TemplateDecl *Template);

/// Build a new template name given a nested name specifier and the
/// name that is referred to as a template.
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 const IdentifierInfo &Name,
                                 SourceLocation NameLoc, QualType ObjectType,
                                 NamedDecl *FirstQualifierInScope,
                                 bool AllowInjectedClassName);

/// Build a new template name given a nested name specifier and the
/// overloaded operator name that is referred to as a template.
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 OverloadedOperatorKind Operator,
                                 SourceLocation NameLoc, QualType ObjectType,
                                 bool AllowInjectedClassName);

/// Build a new template name given a template template parameter pack
/// and the
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(const TemplateArgument &ArgPack,
                                 Decl *AssociatedDecl, unsigned Index,
                                 bool Final) {
  return getSema().Context.getSubstTemplateTemplateParmPack(
      ArgPack, AssociatedDecl, Index, Final);
}

/// Build a new compound statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
                                     MultiStmtArg Statements,
                                     SourceLocation RBraceLoc,
                                     bool IsStmtExpr) {
  return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
                                     IsStmtExpr);
}

/// Build a new case statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
                                 Expr *LHS,
                                 SourceLocation EllipsisLoc,
                                 Expr *RHS,
                                 SourceLocation ColonLoc) {
  return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
                                 ColonLoc);
}

/// Attach the body to a new case statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
  getSema().ActOnCaseStmtBody(S, Body);
  return S;
}

/// Build a new default statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
                                    SourceLocation ColonLoc,
                                    Stmt *SubStmt) {
  return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
                                    /*CurScope=*/nullptr);
}

/// Build a new label statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
                            SourceLocation ColonLoc, Stmt *SubStmt) {
  return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
}

/// Build a new attributed statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
                                 ArrayRef<const Attr *> Attrs,
                                 Stmt *SubStmt) {
  return SemaRef.BuildAttributedStmt(AttrLoc, Attrs, SubStmt);
}

/// Build a new "if" statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildIfStmt(SourceLocation IfLoc, IfStatementKind Kind,
                         SourceLocation LParenLoc, Sema::ConditionResult Cond,
                         SourceLocation RParenLoc, Stmt *Init, Stmt *Then,
                         SourceLocation ElseLoc, Stmt *Else) {
  return getSema().ActOnIfStmt(IfLoc, Kind, LParenLoc, Init, Cond, RParenLoc,
                               Then, ElseLoc, Else);
}

/// Start building a new switch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
                                  SourceLocation LParenLoc, Stmt *Init,
                                  Sema::ConditionResult Cond,
                                  SourceLocation RParenLoc) {
  return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond,
                                          RParenLoc);
}

/// Attach the body to the switch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
                                 Stmt *Switch, Stmt *Body) {
  return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
}

/// Build a new while statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
                            Sema::ConditionResult Cond,
                            SourceLocation RParenLoc, Stmt *Body) {
  return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body);
}

/// Build a new do-while statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
                         SourceLocation WhileLoc, SourceLocation LParenLoc,
                         Expr *Cond, SourceLocation RParenLoc) {
  return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
                               Cond, RParenLoc);
}

/// Build a new for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
                          Stmt *Init, Sema::ConditionResult Cond,
                          Sema::FullExprArg Inc, SourceLocation RParenLoc,
                          Stmt *Body) {
  return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
                                Inc, RParenLoc, Body);
}

/// Build a new goto statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
                           LabelDecl *Label) {
  return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
}

/// Build a new indirect goto statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
                                   SourceLocation StarLoc,
                                   Expr *Target) {
  return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
}

/// Build a new return statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
  return getSema().BuildReturnStmt(ReturnLoc, Result);
}

/// Build a new declaration statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
                           SourceLocation StartLoc, SourceLocation EndLoc) {
  Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
  return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
}

/// Build a new inline asm statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                             bool IsVolatile, unsigned NumOutputs,
                             unsigned NumInputs, IdentifierInfo **Names,
                             MultiExprArg Constraints, MultiExprArg Exprs,
                             Expr *AsmString, MultiExprArg Clobbers,
                             unsigned NumLabels,
                             SourceLocation RParenLoc) {
  return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
                                   NumInputs, Names, Constraints, Exprs,
                                   AsmString, Clobbers, NumLabels, RParenLoc);
}

/// Build a new MS style inline asm statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                            ArrayRef<Token> AsmToks,
                            StringRef AsmString,
                            unsigned NumOutputs, unsigned NumInputs,
                            ArrayRef<StringRef> Constraints,
                            ArrayRef<StringRef> Clobbers,
                            ArrayRef<Expr*> Exprs,
                            SourceLocation EndLoc) {
  return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
                                  NumOutputs, NumInputs,
                                  Constraints, Clobbers, Exprs, EndLoc);
}

/// Build a new co_return statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
                               bool IsImplicit) {
  return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
}

/// Build a new co_await expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand,
                              UnresolvedLookupExpr *OpCoawaitLookup,
                              bool IsImplicit) {
  // This function rebuilds a coawait-expr given its operator.
  // For an explicit coawait-expr, the rebuild involves the full set
  // of transformations performed by BuildUnresolvedCoawaitExpr(),
  // including calling await_transform().
  // For an implicit coawait-expr, we need to rebuild the "operator
  // coawait" but not await_transform(), so use BuildResolvedCoawaitExpr().
  // This mirrors how the implicit CoawaitExpr is originally created
  // in Sema::ActOnCoroutineBodyStart().
  if (IsImplicit) {
    ExprResult Suspend = getSema().BuildOperatorCoawaitCall(
        CoawaitLoc, Operand, OpCoawaitLookup);
    if (Suspend.isInvalid())
      return ExprError();
    return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Operand,
                                              Suspend.get(), true);
  }

  return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Operand,
                                              OpCoawaitLookup);
}

/// Build a new co_await expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
                                       Expr *Result,
                                       UnresolvedLookupExpr *Lookup) {
  return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
}

/// Build a new co_yield expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
  return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
}

StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
  return getSema().BuildCoroutineBodyStmt(Args);
}

/// Build a new Objective-C \@try statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
                                      Stmt *TryBody,
                                      MultiStmtArg CatchStmts,
                                      Stmt *Finally) {
  return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
                                      Finally);
}

/// Rebuild an Objective-C exception declaration.
///
/// By default, performs semantic analysis to build the new declaration.
/// Subclasses may override this routine to provide different behavior.
VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
                                  TypeSourceInfo *TInfo, QualType T) {
  return getSema().BuildObjCExceptionDecl(TInfo, T,
                                          ExceptionDecl->getInnerLocStart(),
                                          ExceptionDecl->getLocation(),
                                          ExceptionDecl->getIdentifier());
}

/// Build a new Objective-C \@catch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
                                        SourceLocation RParenLoc,
                                        VarDecl *Var,
                                        Stmt *Body) {
  return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
                                        Var, Body);
}

/// Build a new Objective-C \@finally statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
                                          Stmt *Body) {
  return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
}

/// Build a new Objective-C \@throw statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
                                        Expr *Operand) {
  return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
}

/// Build a new OpenMP Canonical loop.
///
/// Ensures that the outermost loop in @p LoopStmt is wrapped by a
/// OMPCanonicalLoop.
StmtResult RebuildOMPCanonicalLoop(Stmt *LoopStmt) {
  return getSema().ActOnOpenMPCanonicalLoop(LoopStmt);
}

/// Build a new OpenMP executable directive.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
                                         DeclarationNameInfo DirName,
                                         OpenMPDirectiveKind CancelRegion,
                                         ArrayRef<OMPClause *> Clauses,
                                         Stmt *AStmt, SourceLocation StartLoc,
                                         SourceLocation EndLoc) {
  return getSema().ActOnOpenMPExecutableDirective(
      Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
}

/// Build a new OpenMP 'if' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
                              Expr *Condition, SourceLocation StartLoc,
                              SourceLocation LParenLoc,
                              SourceLocation NameModifierLoc,
                              SourceLocation ColonLoc,
                              SourceLocation EndLoc) {
  return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
                                       LParenLoc, NameModifierLoc, ColonLoc,
                                       EndLoc);
}

/// Build a new OpenMP 'final' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
                                          EndLoc);
}

/// Build a new OpenMP 'num_threads' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
                                               LParenLoc, EndLoc);
}

/// Build a new OpenMP 'safelen' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'simdlen' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
}

OMPClause *RebuildOMPSizesClause(ArrayRef<Expr *> Sizes,
                                 SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSizesClause(Sizes, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'full' clause.
OMPClause *RebuildOMPFullClause(SourceLocation StartLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFullClause(StartLoc, EndLoc);
}

/// Build a new OpenMP 'partial' clause.
OMPClause *RebuildOMPPartialClause(Expr *Factor, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPartialClause(Factor, StartLoc, LParenLoc,
                                            EndLoc);
}

/// Build a new OpenMP 'allocator' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'collapse' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'default' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
                                            StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'proc_bind' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPProcBindClause(ProcBindKind Kind,
                                    SourceLocation KindKwLoc,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
                                             StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'schedule' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPScheduleClause(
    OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
    OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
    SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPScheduleClause(
      M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
      CommaLoc, EndLoc);
}

/// Build a new OpenMP 'ordered' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
                                   SourceLocation EndLoc,
                                   SourceLocation LParenLoc, Expr *Num) {
  return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
}

/// Build a new OpenMP 'private' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
                                            EndLoc);
}

/// Build a new OpenMP 'firstprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
                                        SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
                                                 EndLoc);
}

/// Build a new OpenMP 'lastprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
                                       OpenMPLastprivateModifier LPKind,
                                       SourceLocation LPKindLoc,
                                       SourceLocation ColonLoc,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPLastprivateClause(
      VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'shared' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPReductionClause(
    ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
    SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation ModifierLoc, SourceLocation ColonLoc,
    SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
    const DeclarationNameInfo &ReductionId,
    ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPReductionClause(
      VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
      ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'task_reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPTaskReductionClause(
    ArrayRef<Expr *> VarList, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
    CXXScopeSpec &ReductionIdScopeSpec,
    const DeclarationNameInfo &ReductionId,
    ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPTaskReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'in_reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
                            SourceLocation LParenLoc, SourceLocation ColonLoc,
                            SourceLocation EndLoc,
                            CXXScopeSpec &ReductionIdScopeSpec,
                            const DeclarationNameInfo &ReductionId,
                            ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPInReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'linear' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  OpenMPLinearClauseKind Modifier,
                                  SourceLocation ModifierLoc,
                                  SourceLocation ColonLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
                                           Modifier, ModifierLoc, ColonLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'aligned' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation ColonLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
                                            LParenLoc, ColonLoc, EndLoc);
}

/// Build a new OpenMP 'copyin' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'copyprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
                                                EndLoc);
}

/// Build a new OpenMP 'flush' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
                                 SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
                                          EndLoc);
}

/// Build a new OpenMP 'depobj' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDepobjClause(Depobj, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'depend' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDependClause(OMPDependClause::DependDataTy Data,
                                  Expr *DepModifier, ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDependClause(Data, DepModifier, VarList,
                                           StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'device' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
                                  Expr *Device, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation ModifierLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDeviceClause(Modifier, Device, StartLoc,
                                           LParenLoc, ModifierLoc, EndLoc);
}

/// Build a new OpenMP 'map' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPMapClause(
    Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
    ArrayRef<SourceLocation> MapTypeModifiersLoc,
    CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId,
    OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
    SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
    const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPMapClause(
      IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
      MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
      ColonLoc, VarList, Locs,
      /*NoDiagnose=*/false, UnresolvedMappers);
}

/// Build a new OpenMP 'allocate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAllocateClause(Expr *Allocate, ArrayRef<Expr *> VarList,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ColonLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAllocateClause(Allocate, VarList, StartLoc,
                                             LParenLoc, ColonLoc, EndLoc);
}

/// Build a new OpenMP 'num_teams' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'thread_limit' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
                                                LParenLoc, EndLoc);
}

/// Build a new OpenMP 'priority' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'grainsize' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier,
                                     Expr *Device, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation ModifierLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPGrainsizeClause(Modifier, Device, StartLoc,
                                              LParenLoc, ModifierLoc, EndLoc);
}

/// Build a new OpenMP 'num_tasks' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier,
                                    Expr *NumTasks, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ModifierLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumTasksClause(Modifier, NumTasks, StartLoc,
                                             LParenLoc, ModifierLoc, EndLoc);
}

/// Build a new OpenMP 'hint' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'detach' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDetachClause(Expr *Evt, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'dist_schedule' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
                             Expr *ChunkSize, SourceLocation StartLoc,
                             SourceLocation LParenLoc, SourceLocation KindLoc,
                             SourceLocation CommaLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDistScheduleClause(
      Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
}

/// Build a new OpenMP 'to' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
                   ArrayRef<SourceLocation> MotionModifiersLoc,
                   CXXScopeSpec &MapperIdScopeSpec,
                   DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
                   ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
                   ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPToClause(MotionModifiers, MotionModifiersLoc,
                                       MapperIdScopeSpec, MapperId, ColonLoc,
                                       VarList, Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'from' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
                     ArrayRef<SourceLocation> MotionModifiersLoc,
                     CXXScopeSpec &MapperIdScopeSpec,
                     DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
                     ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
                     ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPFromClause(
      MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
      ColonLoc, VarList, Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'use_device_ptr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
                                        const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPUseDevicePtrClause(VarList, Locs);
}

/// Build a new OpenMP 'use_device_addr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
                                         const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPUseDeviceAddrClause(VarList, Locs);
}

/// Build a new OpenMP 'is_device_ptr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
                                       const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
}

/// Build a new OpenMP 'has_device_addr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPHasDeviceAddrClause(ArrayRef<Expr *> VarList,
                                         const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPHasDeviceAddrClause(VarList, Locs);
}

/// Build a new OpenMP 'defaultmap' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDefaultmapClause(OpenMPDefaultmapClauseModifier M,
                                      OpenMPDefaultmapClauseKind Kind,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation MLoc,
                                      SourceLocation KindLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDefaultmapClause(M, Kind, StartLoc, LParenLoc,
                                               MLoc, KindLoc, EndLoc);
}

/// Build a new OpenMP 'nontemporal' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNontemporalClause(ArrayRef<Expr *> VarList,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNontemporalClause(VarList, StartLoc, LParenLoc,
                                                EndLoc);
}

/// Build a new OpenMP 'inclusive' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPInclusiveClause(ArrayRef<Expr *> VarList,
                                     SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPInclusiveClause(VarList, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'exclusive' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPExclusiveClause(ArrayRef<Expr *> VarList,
                                     SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPExclusiveClause(VarList, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'uses_allocators' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUsesAllocatorsClause(
    ArrayRef<Sema::UsesAllocatorsData> Data, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPUsesAllocatorClause(StartLoc, LParenLoc, EndLoc,
                                                  Data);
}

/// Build a new OpenMP 'affinity' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAffinityClause(SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ColonLoc,
                                    SourceLocation EndLoc, Expr *Modifier,
                                    ArrayRef<Expr *> Locators) {
  return getSema().ActOnOpenMPAffinityClause(StartLoc, LParenLoc, ColonLoc,
                                             EndLoc, Modifier, Locators);
}

/// Build a new OpenMP 'order' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPOrderClause(
    OpenMPOrderClauseKind Kind, SourceLocation KindKwLoc,
    SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc,
    OpenMPOrderClauseModifier Modifier, SourceLocation ModifierKwLoc) {
  return getSema().ActOnOpenMPOrderClause(Modifier, Kind, StartLoc, LParenLoc,
                                          ModifierKwLoc, KindKwLoc, EndLoc);
}

/// Build a new OpenMP 'init' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo,
                                SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation VarLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPInitClause(InteropVar, InteropInfo, StartLoc,
                                         LParenLoc, VarLoc, EndLoc);
}

/// Build a new OpenMP 'use' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
                               SourceLocation LParenLoc,
                               SourceLocation VarLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPUseClause(InteropVar, StartLoc, LParenLoc,
                                        VarLoc, EndLoc);
}

/// Build a new OpenMP 'destroy' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation VarLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDestroyClause(InteropVar, StartLoc, LParenLoc,
                                            VarLoc, EndLoc);
}

/// Build a new OpenMP 'novariants' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNovariantsClause(Expr *Condition,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNovariantsClause(Condition, StartLoc, LParenLoc,
                                               EndLoc);
}

/// Build a new OpenMP 'nocontext' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNocontextClause(Expr *Condition, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNocontextClause(Condition, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'filter' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFilterClause(ThreadID, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'bind' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPBindClause(OpenMPBindClauseKind Kind,
                                SourceLocation KindLoc,
                                SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPBindClause(Kind, KindLoc, StartLoc, LParenLoc,
                                         EndLoc);
}

/// Build a new OpenMP 'ompx_dyn_cgroup_mem' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPXDynCGroupMemClause(Expr *Size, SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
                                         SourceLocation EndLoc) {
  return getSema().ActOnOpenMPXDynCGroupMemClause(Size, StartLoc, LParenLoc,
                                                  EndLoc);
}

/// Build a new OpenMP 'align' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAlignClause(Expr *A, SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'at' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAtClause(OpenMPAtClauseKind Kind, SourceLocation KwLoc,
                              SourceLocation StartLoc,
                              SourceLocation LParenLoc,
                              SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAtClause(Kind, KwLoc, StartLoc, LParenLoc,
                                       EndLoc);
}

/// Build a new OpenMP 'severity' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSeverityClause(OpenMPSeverityClauseKind Kind,
                                    SourceLocation KwLoc,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSeverityClause(Kind, KwLoc, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'message' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPMessageClause(Expr *MS, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPMessageClause(MS, StartLoc, LParenLoc, EndLoc);
}

/// Rebuild the operand to an Objective-C \@synchronized statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
                                            Expr *object) {
  return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
}

/// Build a new Objective-C \@synchronized statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
                                         Expr *Object, Stmt *Body) {
  return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
}

/// Build a new Objective-C \@autoreleasepool statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
                                          Stmt *Body) {
  return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
}

/// Build a new Objective-C fast enumeration statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
                                        Stmt *Element,
                                        Expr *Collection,
                                        SourceLocation RParenLoc,
                                        Stmt *Body) {
  StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
                                              Element,
                                              Collection,
                                              RParenLoc);
  if (ForEachStmt.isInvalid())
    return StmtError();

  return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
}

/// Build a new C++ exception declaration.
///
/// By default, performs semantic analysis to build the new decaration.
/// Subclasses may override this routine to provide different behavior.
VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
                              TypeSourceInfo *Declarator,
                              SourceLocation StartLoc,
                              SourceLocation IdLoc,
                              IdentifierInfo *Id) {
  VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
                                                     StartLoc, IdLoc, Id);
  if (Var)
    getSema().CurContext->addDecl(Var);
  return Var;
}

/// Build a new C++ catch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
                               VarDecl *ExceptionDecl,
                               Stmt *Handler) {
  return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
                                                    Handler));
}

/// Build a new C++ try statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
                             ArrayRef<Stmt *> Handlers) {
  return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
}

/// Build a new C++0x range-based for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
                                  SourceLocation CoawaitLoc, Stmt *Init,
                                  SourceLocation ColonLoc, Stmt *Range,
                                  Stmt *Begin, Stmt *End, Expr *Cond,
                                  Expr *Inc, Stmt *LoopVar,
                                  SourceLocation RParenLoc) {
  // If we've just learned that the range is actually an Objective-C
  // collection, treat this as an Objective-C fast enumeration loop.
  if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
    if (RangeStmt->isSingleDecl()) {
      if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
        if (RangeVar->isInvalidDecl())
          return StmtError();

        Expr *RangeExpr = RangeVar->getInit();
        if (!RangeExpr->isTypeDependent() &&
            RangeExpr->getType()->isObjCObjectPointerType()) {
          // FIXME: Support init-statements in Objective-C++20 ranged for
          // statement.
          if (Init) {
            return SemaRef.Diag(Init->getBeginLoc(),
                                diag::err_objc_for_range_init_stmt)
                       << Init->getSourceRange();
          }
          return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar,
                                                      RangeExpr, RParenLoc);
        }
      }
    }
  }

  return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, Init, ColonLoc,
                                        Range, Begin, End, Cond, Inc, LoopVar,
                                        RParenLoc, Sema::BFRK_Rebuild);
}

/// Build a new C++0x range-based for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
                                        bool IsIfExists,
                                        NestedNameSpecifierLoc QualifierLoc,
                                        DeclarationNameInfo NameInfo,
                                        Stmt *Nested) {
  return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
                                              QualifierLoc, NameInfo, Nested);
}

/// Attach body to a C++0x range-based for statement.
///
/// By default, performs semantic analysis to finish the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
  return getSema().FinishCXXForRangeStmt(ForRange, Body);
}

StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
                             Stmt *TryBlock, Stmt *Handler) {
  return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
}

StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
                                Stmt *Block) {
  return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
}

StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
  return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
}

ExprResult RebuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                           SourceLocation LParen,
                                           SourceLocation RParen,
                                           TypeSourceInfo *TSI) {
  return getSema().BuildSYCLUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
}

/// Build a new predefined expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildPredefinedExpr(SourceLocation Loc,
                                 PredefinedExpr::IdentKind IK) {
  return getSema().BuildPredefinedExpr(Loc, IK);
}

/// Build a new expression that references a declaration.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                      LookupResult &R,
                                      bool RequiresADL) {
  return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
}


/// Build a new expression that references a declaration.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
                              ValueDecl *VD,
                              const DeclarationNameInfo &NameInfo,
                              NamedDecl *Found,
                              TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found,
                                            TemplateArgs);
}

/// Build a new expression in parentheses.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
                                  SourceLocation RParen) {
  return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
}

/// Build a new pseudo-destructor expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
                                          SourceLocation OperatorLoc,
                                          bool isArrow,
                                          CXXScopeSpec &SS,
                                          TypeSourceInfo *ScopeType,
                                          SourceLocation CCLoc,
                                          SourceLocation TildeLoc,
                                      PseudoDestructorTypeStorage Destroyed);

/// Build a new unary operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
                                      UnaryOperatorKind Opc,
                                      Expr *SubExpr) {
  return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
}

/// Build a new builtin offsetof expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
                               TypeSourceInfo *Type,
                               ArrayRef<Sema::OffsetOfComponent> Components,
                               SourceLocation RParenLoc) {
  return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
                                        RParenLoc);
}

/// Build a new sizeof, alignof or vec_step expression with a
/// type argument.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
                                       SourceLocation OpLoc,
                                       UnaryExprOrTypeTrait ExprKind,
                                       SourceRange R) {
  return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
}

/// Build a new sizeof, alignof or vec step expression with an
/// expression argument.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
                                       UnaryExprOrTypeTrait ExprKind,
                                       SourceRange R) {
  ExprResult Result
    = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
  if (Result.isInvalid())
    return ExprError();

  return Result;
}

/// Build a new array subscript expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildArraySubscriptExpr(Expr *LHS,
                                           SourceLocation LBracketLoc,
                                           Expr *RHS,
                                           SourceLocation RBracketLoc) {
  return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
                                           LBracketLoc, RHS,
                                           RBracketLoc);
}

/// Build a new matrix subscript expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
                                      Expr *ColumnIdx,
                                      SourceLocation RBracketLoc) {
  return getSema().CreateBuiltinMatrixSubscriptExpr(Base, RowIdx, ColumnIdx,
                                                    RBracketLoc);
}

/// Build a new array section expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
                                      Expr *LowerBound,
                                      SourceLocation ColonLocFirst,
                                      SourceLocation ColonLocSecond,
                                      Expr *Length, Expr *Stride,
                                      SourceLocation RBracketLoc) {
  return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
                                            ColonLocFirst, ColonLocSecond,
                                            Length, Stride, RBracketLoc);
}

/// Build a new array shaping expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
                                      SourceLocation RParenLoc,
                                      ArrayRef<Expr *> Dims,
                                      ArrayRef<SourceRange> BracketsRanges) {
  return getSema().ActOnOMPArrayShapingExpr(Base, LParenLoc, RParenLoc, Dims,
                                            BracketsRanges);
}

/// Build a new iterator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPIteratorExpr(
    SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc,
    ArrayRef<Sema::OMPIteratorData> Data) {
  return getSema().ActOnOMPIteratorExpr(/*Scope=*/nullptr, IteratorKwLoc,
                                        LLoc, RLoc, Data);
}

/// Build a new call expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
                                 MultiExprArg Args,
                                 SourceLocation RParenLoc,
                                 Expr *ExecConfig = nullptr) {
  return getSema().ActOnCallExpr(
      /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
}

ExprResult RebuildCxxSubscriptExpr(Expr *Callee, SourceLocation LParenLoc,
                                   MultiExprArg Args,
                                   SourceLocation RParenLoc) {
  return getSema().ActOnArraySubscriptExpr(
      /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc);
}

/// Build a new member access expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
                             bool isArrow,
                             NestedNameSpecifierLoc QualifierLoc,
                             SourceLocation TemplateKWLoc,
                             const DeclarationNameInfo &MemberNameInfo,
                             ValueDecl *Member,
                             NamedDecl *FoundDecl,
                      const TemplateArgumentListInfo *ExplicitTemplateArgs,
                             NamedDecl *FirstQualifierInScope) {
  ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
                                                                    isArrow);
  if (!Member->getDeclName()) {
    // We have a reference to an unnamed field.  This is always the
    // base of an anonymous struct/union member access, i.e. the
    // field is always of record type.
    assert(Member->getType()->isRecordType() &&(static_cast <bool> (Member->getType()->isRecordType
() && "unnamed member not of record type?") ? void (0
) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "clang/lib/Sema/TreeTransform.h", 2797, __extension__ __PRETTY_FUNCTION__
))
           "unnamed member not of record type?")(static_cast <bool> (Member->getType()->isRecordType
() && "unnamed member not of record type?") ? void (0
) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "clang/lib/Sema/TreeTransform.h", 2797, __extension__ __PRETTY_FUNCTION__
));

    BaseResult =
      getSema().PerformObjectMemberConversion(BaseResult.get(),
                                              QualifierLoc.getNestedNameSpecifier(),
                                              FoundDecl, Member);
    if (BaseResult.isInvalid())
      return ExprError();
    Base = BaseResult.get();

    CXXScopeSpec EmptySS;
    return getSema().BuildFieldReferenceExpr(
        Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
        DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
  }

  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  Base = BaseResult.get();
  QualType BaseType = Base->getType();

  if (isArrow && !BaseType->isPointerType())
    return ExprError();

  // FIXME: this involves duplicating earlier analysis in a lot of
  // cases; we should avoid this when possible.
  LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
  R.addDecl(FoundDecl);
  R.resolveKind();

  if (getSema().isUnevaluatedContext() && Base->isImplicitCXXThis() &&
      isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(Member)) {
    if (auto *ThisClass = cast<CXXThisExpr>(Base)
                              ->getType()
                              ->getPointeeType()
                              ->getAsCXXRecordDecl()) {
      auto *Class = cast<CXXRecordDecl>(Member->getDeclContext());
      // In unevaluated contexts, an expression supposed to be a member access
      // might reference a member in an unrelated class.
      if (!ThisClass->Equals(Class) && !ThisClass->isDerivedFrom(Class))
        return getSema().BuildDeclRefExpr(Member, Member->getType(),
                                          VK_LValue, Member->getLocation());
    }
  }

  return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
                                            SS, TemplateKWLoc,
                                            FirstQualifierInScope,
                                            R, ExplicitTemplateArgs,
                                            /*S*/nullptr);
}

/// Build a new binary operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
                                       BinaryOperatorKind Opc,
                                       Expr *LHS, Expr *RHS) {
  return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
}

/// Build a new rewritten operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXRewrittenBinaryOperator(
    SourceLocation OpLoc, BinaryOperatorKind Opcode,
    const UnresolvedSetImpl &UnqualLookups, Expr *LHS, Expr *RHS) {
  return getSema().CreateOverloadedBinOp(OpLoc, Opcode, UnqualLookups, LHS,
                                         RHS, /*RequiresADL*/false);
}

/// Build a new conditional operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildConditionalOperator(Expr *Cond,
                                      SourceLocation QuestionLoc,
                                      Expr *LHS,
                                      SourceLocation ColonLoc,
                                      Expr *RHS) {
  return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
                                      LHS, RHS);
}

/// Build a new C-style cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
                                       TypeSourceInfo *TInfo,
                                       SourceLocation RParenLoc,
                                       Expr *SubExpr) {
  return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
                                       SubExpr);
}

/// Build a new compound literal expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
                                            TypeSourceInfo *TInfo,
                                            SourceLocation RParenLoc,
                                            Expr *Init) {
  return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
                                            Init);
}

/// Build a new extended vector element access expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildExtVectorElementExpr(Expr *Base, SourceLocation OpLoc,
                                       bool IsArrow,
                                       SourceLocation AccessorLoc,
                                       IdentifierInfo &Accessor) {

  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
  return getSema().BuildMemberReferenceExpr(
      Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(),
      /*FirstQualifierInScope*/ nullptr, NameInfo,
      /* TemplateArgs */ nullptr,
      /*S*/ nullptr);
}

/// Build a new initializer list expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildInitList(SourceLocation LBraceLoc,
                           MultiExprArg Inits,
                           SourceLocation RBraceLoc) {
  return SemaRef.BuildInitList(LBraceLoc, Inits, RBraceLoc);
}

/// Build a new designated initializer expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDesignatedInitExpr(Designation &Desig,
                                           MultiExprArg ArrayExprs,
                                           SourceLocation EqualOrColonLoc,
                                           bool GNUSyntax,
                                           Expr *Init) {
  ExprResult Result
    = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
                                         Init);
  if (Result.isInvalid())
    return ExprError();

  return Result;
}

/// Build a new value-initialized expression.
///
/// By default, builds the implicit value initialization without performing
/// any semantic analysis. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildImplicitValueInitExpr(QualType T) {
  return new (SemaRef.Context) ImplicitValueInitExpr(T);
}

/// Build a new \c va_arg expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
                                  Expr *SubExpr, TypeSourceInfo *TInfo,
                                  SourceLocation RParenLoc) {
  return getSema().BuildVAArgExpr(BuiltinLoc,
                                  SubExpr, TInfo,
                                  RParenLoc);
}

/// Build a new expression list in parentheses.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
                                MultiExprArg SubExprs,
                                SourceLocation RParenLoc) {
  return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
}

/// Build a new address-of-label expression.
///
/// By default, performs semantic analysis, using the name of the label
/// rather than attempting to map the label statement itself.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
                                SourceLocation LabelLoc, LabelDecl *Label) {
  return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
}

/// Build a new GNU statement expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildStmtExpr(SourceLocation LParenLoc, Stmt *SubStmt,
                           SourceLocation RParenLoc, unsigned TemplateDepth) {
  return getSema().BuildStmtExpr(LParenLoc, SubStmt, RParenLoc,
                                 TemplateDepth);
}

/// Build a new __builtin_choose_expr expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
                                   Expr *Cond, Expr *LHS, Expr *RHS,
                                   SourceLocation RParenLoc) {
  return SemaRef.ActOnChooseExpr(BuiltinLoc,
                                 Cond, LHS, RHS,
                                 RParenLoc);
}

/// Build a new generic selection expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
                                       SourceLocation DefaultLoc,
                                       SourceLocation RParenLoc,
                                       Expr *ControllingExpr,
                                       ArrayRef<TypeSourceInfo *> Types,
                                       ArrayRef<Expr *> Exprs) {
  return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
                                              ControllingExpr, Types, Exprs);
}

/// Build a new overloaded operator call expression.
///
/// By default, performs semantic analysis to build the new expression.
/// The semantic analysis provides the behavior of template instantiation,
/// copying with transformations that turn what looks like an overloaded
/// operator call into a use of a builtin operator, performing
/// argument-dependent lookup, etc. Subclasses may override this routine to
/// provide different behavior.
ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
                                            SourceLocation OpLoc,
                                            Expr *Callee,
                                            Expr *First,
                                            Expr *Second);

/// Build a new C++ "named" cast expression, such as static_cast or
/// reinterpret_cast.
///
/// By default, this routine dispatches to one of the more-specific routines
/// for a particular named case, e.g., RebuildCXXStaticCastExpr().
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
                                         Stmt::StmtClass Class,
                                         SourceLocation LAngleLoc,
                                         TypeSourceInfo *TInfo,
                                         SourceLocation RAngleLoc,
                                         SourceLocation LParenLoc,
                                         Expr *SubExpr,
                                         SourceLocation RParenLoc) {
  switch (Class) {
  case Stmt::CXXStaticCastExprClass:
    return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
                                                 RAngleLoc, LParenLoc,
                                                 SubExpr, RParenLoc);

  case Stmt::CXXDynamicCastExprClass:
    return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
                                                  RAngleLoc, LParenLoc,
                                                  SubExpr, RParenLoc);

  case Stmt::CXXReinterpretCastExprClass:
    return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
                                                      RAngleLoc, LParenLoc,
                                                      SubExpr,
                                                      RParenLoc);

  case Stmt::CXXConstCastExprClass:
    return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
                                                 RAngleLoc, LParenLoc,
                                                 SubExpr, RParenLoc);

  case Stmt::CXXAddrspaceCastExprClass:
    return getDerived().RebuildCXXAddrspaceCastExpr(
        OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);

  default:
    llvm_unreachable("Invalid C++ named cast")::llvm::llvm_unreachable_internal("Invalid C++ named cast", "clang/lib/Sema/TreeTransform.h"
, 3086);
  }
}

/// Build a new C++ static_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
                                          SourceLocation LAngleLoc,
                                          TypeSourceInfo *TInfo,
                                          SourceLocation RAngleLoc,
                                          SourceLocation LParenLoc,
                                          Expr *SubExpr,
                                          SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ dynamic_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
                                           SourceLocation LAngleLoc,
                                           TypeSourceInfo *TInfo,
                                           SourceLocation RAngleLoc,
                                           SourceLocation LParenLoc,
                                           Expr *SubExpr,
                                           SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ reinterpret_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
                                               SourceLocation LAngleLoc,
                                               TypeSourceInfo *TInfo,
                                               SourceLocation RAngleLoc,
                                               SourceLocation LParenLoc,
                                               Expr *SubExpr,
                                               SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ const_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
                                         SourceLocation LAngleLoc,
                                         TypeSourceInfo *TInfo,
                                         SourceLocation RAngleLoc,
                                         SourceLocation LParenLoc,
                                         Expr *SubExpr,
                                         SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

ExprResult
RebuildCXXAddrspaceCastExpr(SourceLocation OpLoc, SourceLocation LAngleLoc,
                            TypeSourceInfo *TInfo, SourceLocation RAngleLoc,
                            SourceLocation LParenLoc, Expr *SubExpr,
                            SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(
      OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
      SourceRange(LAngleLoc, RAngleLoc), SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ functional-style cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
                                        SourceLocation LParenLoc,
                                        Expr *Sub,
                                        SourceLocation RParenLoc,
                                        bool ListInitialization) {
  // If Sub is a ParenListExpr, then Sub is the syntatic form of a
  // CXXParenListInitExpr. Pass its expanded arguments so that the
  // CXXParenListInitExpr can be rebuilt.
  if (auto *PLE = dyn_cast<ParenListExpr>(Sub))
    return getSema().BuildCXXTypeConstructExpr(
        TInfo, LParenLoc, MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
        RParenLoc, ListInitialization);
  return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
                                             MultiExprArg(&Sub, 1), RParenLoc,
                                             ListInitialization);
}

/// Build a new C++ __builtin_bit_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc,
                                     TypeSourceInfo *TSI, Expr *Sub,
                                     SourceLocation RParenLoc) {
  return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc);
}

/// Build a new C++ typeid(type) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      TypeSourceInfo *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}


/// Build a new C++ typeid(expr) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      Expr *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}

/// Build a new C++ __uuidof(type) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
                                TypeSourceInfo *Operand,
                                SourceLocation RParenLoc) {
  return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
}

/// Build a new C++ __uuidof(expr) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
                                Expr *Operand, SourceLocation RParenLoc) {
  return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
}

/// Build a new C++ "this" expression.
///
/// By default, builds a new "this" expression without performing any
/// semantic analysis. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
                              QualType ThisType,
                              bool isImplicit) {
  return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit);
}

/// Build a new C++ throw expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
                               bool IsThrownVariableInScope) {
  return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
}

/// Build a new C++ default-argument expression.
///
/// By default, builds a new default-argument expression, which does not
/// require any semantic analysis. Subclasses may override this routine to
/// provide different behavior.
ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param,
                                    Expr *RewrittenExpr) {
  return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
                                   RewrittenExpr, getSema().CurContext);
}

/// Build a new C++11 default-initialization expression.
///
/// By default, builds a new default field initialization expression, which
/// does not require any semantic analysis. Subclasses may override this
/// routine to provide different behavior.
ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
                                     FieldDecl *Field) {
  return getSema().BuildCXXDefaultInitExpr(Loc, Field);
}

/// Build a new C++ zero-initialization expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
                                         SourceLocation LParenLoc,
                                         SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, std::nullopt,
                                             RParenLoc,
                                             /*ListInitialization=*/false);
}

/// Build a new C++ "new" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal,
                             SourceLocation PlacementLParen,
                             MultiExprArg PlacementArgs,
                             SourceLocation PlacementRParen,
                             SourceRange TypeIdParens, QualType AllocatedType,
                             TypeSourceInfo *AllocatedTypeInfo,
                             std::optional<Expr *> ArraySize,
                             SourceRange DirectInitRange, Expr *Initializer) {
  return getSema().BuildCXXNew(StartLoc, UseGlobal,
                               PlacementLParen,
                               PlacementArgs,
                               PlacementRParen,
                               TypeIdParens,
                               AllocatedType,
                               AllocatedTypeInfo,
                               ArraySize,
                               DirectInitRange,
                               Initializer);
}

/// Build a new C++ "delete" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
                                      bool IsGlobalDelete,
                                      bool IsArrayForm,
                                      Expr *Operand) {
  return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
                                  Operand);
}

/// Build a new type trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildTypeTrait(TypeTrait Trait,
                            SourceLocation StartLoc,
                            ArrayRef<TypeSourceInfo *> Args,
                            SourceLocation RParenLoc) {
  return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
}

/// Build a new array type trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
                                 SourceLocation StartLoc,
                                 TypeSourceInfo *TSInfo,
                                 Expr *DimExpr,
                                 SourceLocation RParenLoc) {
  return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
}

/// Build a new expression trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
                                 SourceLocation StartLoc,
                                 Expr *Queried,
                                 SourceLocation RParenLoc) {
  return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
}

/// Build a new (previously unresolved) declaration reference
/// expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDependentScopeDeclRefExpr(
                                        NestedNameSpecifierLoc QualifierLoc,
                                        SourceLocation TemplateKWLoc,
                                     const DeclarationNameInfo &NameInfo,
                            const TemplateArgumentListInfo *TemplateArgs,
                                        bool IsAddressOfOperand,
                                        TypeSourceInfo **RecoveryTSI) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  if (TemplateArgs || TemplateKWLoc.isValid())
    return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
                                                  TemplateArgs);

  return getSema().BuildQualifiedDeclarationNameExpr(
      SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
}

/// Build a new template-id expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 LookupResult &R,
                                 bool RequiresADL,
                            const TemplateArgumentListInfo *TemplateArgs) {
  return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
                                       TemplateArgs);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXConstructExpr(QualType T,
                                   SourceLocation Loc,
                                   CXXConstructorDecl *Constructor,
                                   bool IsElidable,
                                   MultiExprArg Args,
                                   bool HadMultipleCandidates,
                                   bool ListInitialization,
                                   bool StdInitListInitialization,
                                   bool RequiresZeroInit,
                           CXXConstructExpr::ConstructionKind ConstructKind,
                                   SourceRange ParenRange) {
  // Reconstruct the constructor we originally found, which might be
  // different if this is a call to an inherited constructor.
  CXXConstructorDecl *FoundCtor = Constructor;
  if (Constructor->isInheritingConstructor())
    FoundCtor = Constructor->getInheritedConstructor().getConstructor();

  SmallVector<Expr *, 8> ConvertedArgs;
  if (getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
                                        ConvertedArgs))
    return ExprError();

  return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
                                         IsElidable,
                                         ConvertedArgs,
                                         HadMultipleCandidates,
                                         ListInitialization,
                                         StdInitListInitialization,
                                         RequiresZeroInit, ConstructKind,
                                         ParenRange);
}

/// Build a new implicit construction via inherited constructor
/// expression.
ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
                                           CXXConstructorDecl *Constructor,
                                           bool ConstructsVBase,
                                           bool InheritedFromVBase) {
  return new (getSema().Context) CXXInheritedCtorInitExpr(
      Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
                                         SourceLocation LParenOrBraceLoc,
                                         MultiExprArg Args,
                                         SourceLocation RParenOrBraceLoc,
                                         bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(
      TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
                                             SourceLocation LParenLoc,
                                             MultiExprArg Args,
                                             SourceLocation RParenLoc,
                                             bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
                                             RParenLoc, ListInitialization);
}

/// Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
                                              QualType BaseType,
                                              bool IsArrow,
                                              SourceLocation OperatorLoc,
                                        NestedNameSpecifierLoc QualifierLoc,
                                              SourceLocation TemplateKWLoc,
                                          NamedDecl *FirstQualifierInScope,
                                 const DeclarationNameInfo &MemberNameInfo,
                            const TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                          OperatorLoc, IsArrow,
                                          SS, TemplateKWLoc,
                                          FirstQualifierInScope,
                                          MemberNameInfo,
                                          TemplateArgs, /*S*/nullptr);
}

/// Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
                                       SourceLocation OperatorLoc,
                                       bool IsArrow,
                                       NestedNameSpecifierLoc QualifierLoc,
                                       SourceLocation TemplateKWLoc,
                                       NamedDecl *FirstQualifierInScope,
                                       LookupResult &R,
                              const TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                          OperatorLoc, IsArrow,
                                          SS, TemplateKWLoc,
                                          FirstQualifierInScope,
                                          R, TemplateArgs, /*S*/nullptr);
}

/// Build a new noexcept expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
  return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
}

/// Build a new expression to compute the length of a parameter pack.
ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack,
                                 SourceLocation PackLoc,
                                 SourceLocation RParenLoc,
                                 std::optional<unsigned> Length,
                                 ArrayRef<TemplateArgument> PartialArgs) {
  return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
                                RParenLoc, Length, PartialArgs);
}

/// Build a new expression representing a call to a source location
///  builtin.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                QualType ResultTy, SourceLocation BuiltinLoc,
                                SourceLocation RPLoc,
                                DeclContext *ParentContext) {
  return getSema().BuildSourceLocExpr(Kind, ResultTy, BuiltinLoc, RPLoc,
                                      ParentContext);
}

/// Build a new Objective-C boxed expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
    SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
    NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
    TemplateArgumentListInfo *TALI) {
  CXXScopeSpec SS;
  SS.Adopt(NNS);
  ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
                                                       ConceptNameInfo,
                                                       FoundDecl,
                                                       NamedConcept, TALI);
  if (Result.isInvalid())
    return ExprError();
  return Result;
}

/// \brief Build a new requires expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
                               RequiresExprBodyDecl *Body,
                               ArrayRef<ParmVarDecl *> LocalParameters,
                               ArrayRef<concepts::Requirement *> Requirements,
                               SourceLocation ClosingBraceLoc) {
  return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body,
                              LocalParameters, Requirements, ClosingBraceLoc);
}

concepts::TypeRequirement *
RebuildTypeRequirement(
    concepts::Requirement::SubstitutionDiagnostic *SubstDiag) {
  return SemaRef.BuildTypeRequirement(SubstDiag);
}

concepts::TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) {
  return SemaRef.BuildTypeRequirement(T);
}

concepts::ExprRequirement *
RebuildExprRequirement(
    concepts::Requirement::SubstitutionDiagnostic *SubstDiag, bool IsSimple,
    SourceLocation NoexceptLoc,
    concepts::ExprRequirement::ReturnTypeRequirement Ret) {
  return SemaRef.BuildExprRequirement(SubstDiag, IsSimple, NoexceptLoc,
                                      std::move(Ret));
}

concepts::ExprRequirement *
RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
                       concepts::ExprRequirement::ReturnTypeRequirement Ret) {
  return SemaRef.BuildExprRequirement(E, IsSimple, NoexceptLoc,
                                      std::move(Ret));
}

concepts::NestedRequirement *
RebuildNestedRequirement(StringRef InvalidConstraintEntity,
                         const ASTConstraintSatisfaction &Satisfaction) {
  return SemaRef.BuildNestedRequirement(InvalidConstraintEntity,
                                        Satisfaction);
}

concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) {
  return SemaRef.BuildNestedRequirement(Constraint);
}

/// \brief Build a new Objective-C boxed expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
  return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
}

/// Build a new Objective-C array literal.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCArrayLiteral(SourceRange Range,
                                   Expr **Elements, unsigned NumElements) {
  return getSema().BuildObjCArrayLiteral(Range,
                                         MultiExprArg(Elements, NumElements));
}

ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
                                       Expr *Base, Expr *Key,
                                       ObjCMethodDecl *getterMethod,
                                       ObjCMethodDecl *setterMethod) {
  return  getSema().BuildObjCSubscriptExpression(RB, Base, Key,
                                                 getterMethod, setterMethod);
}

/// Build a new Objective-C dictionary literal.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
                            MutableArrayRef<ObjCDictionaryElement> Elements) {
  return getSema().BuildObjCDictionaryLiteral(Range, Elements);
}

/// Build a new Objective-C \@encode expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
                                       TypeSourceInfo *EncodeTypeInfo,
                                       SourceLocation RParenLoc) {
  return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
}

/// Build a new Objective-C class message.
ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
                                        Selector Sel,
                                        ArrayRef<SourceLocation> SelectorLocs,
                                        ObjCMethodDecl *Method,
                                        SourceLocation LBracLoc,
                                        MultiExprArg Args,
                                        SourceLocation RBracLoc) {
  return SemaRef.BuildClassMessage(ReceiverTypeInfo,
                                   ReceiverTypeInfo->getType(),
                                   /*SuperLoc=*/SourceLocation(),
                                   Sel, Method, LBracLoc, SelectorLocs,
                                   RBracLoc, Args);
}

/// Build a new Objective-C instance message.
ExprResult RebuildObjCMessageExpr(Expr *Receiver,
                                        Selector Sel,
                                        ArrayRef<SourceLocation> SelectorLocs,
                                        ObjCMethodDecl *Method,
                                        SourceLocation LBracLoc,
                                        MultiExprArg Args,
                                        SourceLocation RBracLoc) {
  return SemaRef.BuildInstanceMessage(Receiver,
                                      Receiver->getType(),
                                      /*SuperLoc=*/SourceLocation(),
                                      Sel, Method, LBracLoc, SelectorLocs,
                                      RBracLoc, Args);
}

/// Build a new Objective-C instance/class message to 'super'.
ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
                                  Selector Sel,
                                  ArrayRef<SourceLocation> SelectorLocs,
                                  QualType SuperType,
                                  ObjCMethodDecl *Method,
                                  SourceLocation LBracLoc,
                                  MultiExprArg Args,
                                  SourceLocation RBracLoc) {
  return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr,
                                        SuperType,
                                        SuperLoc,
                                        Sel, Method, LBracLoc, SelectorLocs,
                                        RBracLoc, Args)
                                    : SemaRef.BuildClassMessage(nullptr,
                                        SuperType,
                                        SuperLoc,
                                        Sel, Method, LBracLoc, SelectorLocs,
                                        RBracLoc, Args);


}

/// Build a new Objective-C ivar reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
                                        SourceLocation IvarLoc,
                                        bool IsArrow, bool IsFreeIvar) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
  ExprResult Result = getSema().BuildMemberReferenceExpr(
      BaseArg, BaseArg->getType(),
      /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(),
      /*FirstQualifierInScope=*/nullptr, NameInfo,
      /*TemplateArgs=*/nullptr,
      /*S=*/nullptr);
  if (IsFreeIvar && Result.isUsable())
    cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
  return Result;
}

/// Build a new Objective-C property reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
                                      ObjCPropertyDecl *Property,
                                      SourceLocation PropertyLoc) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
  return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
                                            /*FIXME:*/PropertyLoc,
                                            /*IsArrow=*/false,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope=*/nullptr,
                                            NameInfo,
                                            /*TemplateArgs=*/nullptr,
                                            /*S=*/nullptr);
}

/// Build a new Objective-C property reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
                                      ObjCMethodDecl *Getter,
                                      ObjCMethodDecl *Setter,
                                      SourceLocation PropertyLoc) {
  // Since these expressions can only be value-dependent, we do not
  // need to perform semantic analysis again.
  return Owned(
    new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
                                                VK_LValue, OK_ObjCProperty,
                                                PropertyLoc, Base));
}

/// Build a new Objective-C "isa" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
                              SourceLocation OpLoc, bool IsArrow) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
  return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
                                            OpLoc, IsArrow,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope=*/nullptr,
                                            NameInfo,
                                            /*TemplateArgs=*/nullptr,
                                            /*S=*/nullptr);
}

/// Build a new shuffle vector expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
                                    MultiExprArg SubExprs,
                                    SourceLocation RParenLoc) {
  // Find the declaration for __builtin_shufflevector
  const IdentifierInfo &Name
    = SemaRef.Context.Idents.get("__builtin_shufflevector");
  TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
  DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
  assert(!Lookup.empty() && "No __builtin_shufflevector?")(static_cast <bool> (!Lookup.empty() && "No __builtin_shufflevector?"
) ? void (0) : __assert_fail ("!Lookup.empty() && \"No __builtin_shufflevector?\""
, "clang/lib/Sema/TreeTransform.h", 3802, __extension__ __PRETTY_FUNCTION__
));

  // Build a reference to the __builtin_shufflevector builtin
  FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
  Expr *Callee = new (SemaRef.Context)
      DeclRefExpr(SemaRef.Context, Builtin, false,
                  SemaRef.Context.BuiltinFnTy, VK_PRValue, BuiltinLoc);
  QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
  Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
                                     CK_BuiltinFnToFnPtr).get();

  // Build the CallExpr
  ExprResult TheCall = CallExpr::Create(
      SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
      Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc,
      FPOptionsOverride());

  // Type-check the __builtin_shufflevector expression.
  return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
}

/// Build a new convert vector expression.
ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
                                    Expr *SrcExpr, TypeSourceInfo *DstTInfo,
                                    SourceLocation RParenLoc) {
  return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
                                       BuiltinLoc, RParenLoc);
}

/// Build a new template argument pack expansion.
///
/// By default, performs semantic analysis to build a new pack expansion
/// for a template argument. Subclasses may override this routine to provide
/// different behavior.
TemplateArgumentLoc
RebuildPackExpansion(TemplateArgumentLoc Pattern, SourceLocation EllipsisLoc,
                     std::optional<unsigned> NumExpansions) {
  switch (Pattern.getArgument().getKind()) {
  case TemplateArgument::Expression: {
    ExprResult Result
      = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
                                     EllipsisLoc, NumExpansions);
    if (Result.isInvalid())
      return TemplateArgumentLoc();

    return TemplateArgumentLoc(Result.get(), Result.get());
  }

  case TemplateArgument::Template:
    return TemplateArgumentLoc(
        SemaRef.Context,
        TemplateArgument(Pattern.getArgument().getAsTemplate(),
                         NumExpansions),
        Pattern.getTemplateQualifierLoc(), Pattern.getTemplateNameLoc(),
        EllipsisLoc);

  case TemplateArgument::Null:
  case TemplateArgument::Integral:
  case TemplateArgument::Declaration:
  case TemplateArgument::Pack:
  case TemplateArgument::TemplateExpansion:
  case TemplateArgument::NullPtr:
    llvm_unreachable("Pack expansion pattern has no parameter packs")::llvm::llvm_unreachable_internal("Pack expansion pattern has no parameter packs"
, "clang/lib/Sema/TreeTransform.h", 3864);

  case TemplateArgument::Type:
    if (TypeSourceInfo *Expansion
          = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
                                         EllipsisLoc,
                                         NumExpansions))
      return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
                                 Expansion);
    break;
  }

  return TemplateArgumentLoc();
}

/// Build a new expression pack expansion.
///
/// By default, performs semantic analysis to build a new pack expansion
/// for an expression. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
                                std::optional<unsigned> NumExpansions) {
  return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
}

/// Build a new C++1z fold-expression.
///
/// By default, performs semantic analysis in order to build a new fold
/// expression.
ExprResult RebuildCXXFoldExpr(UnresolvedLookupExpr *ULE,
                              SourceLocation LParenLoc, Expr *LHS,
                              BinaryOperatorKind Operator,
                              SourceLocation EllipsisLoc, Expr *RHS,
                              SourceLocation RParenLoc,
                              std::optional<unsigned> NumExpansions) {
  return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator,
                                    EllipsisLoc, RHS, RParenLoc,
                                    NumExpansions);
}

/// Build an empty C++1z fold-expression with the given operator.
///
/// By default, produces the fallback value for the fold-expression, or
/// produce an error if there is no fallback value.
ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
                                   BinaryOperatorKind Operator) {
  return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
}

/// Build a new atomic operation expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs,
                             AtomicExpr::AtomicOp Op,
                             SourceLocation RParenLoc) {
  // Use this for all of the locations, since we don't know the difference
  // between the call and the expr at this point.
  SourceRange Range{BuiltinLoc, RParenLoc};
  return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
                                   Sema::AtomicArgumentOrder::AST);
}

ExprResult RebuildRecoveryExpr(SourceLocation BeginLoc, SourceLocation EndLoc,
                               ArrayRef<Expr *> SubExprs, QualType Type) {
  return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs, Type);
}

3932private:
TypeLoc TransformTypeInObjectScope(TypeLoc TL,
                                   QualType ObjectType,
                                   NamedDecl *FirstQualifierInScope,
                                   CXXScopeSpec &SS);

TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                           QualType ObjectType,
                                           NamedDecl *FirstQualifierInScope,
                                           CXXScopeSpec &SS);

TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
                                          NamedDecl *FirstQualifierInScope,
                                          CXXScopeSpec &SS);

QualType TransformDependentNameType(TypeLocBuilder &TLB,
                                    DependentNameTypeLoc TL,
                                    bool DeducibleTSTContext);
3950};

3952template <typename Derived>
3953StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
if (!S)
  return S;

switch (S->getStmtClass()) {
case Stmt::NoStmtClass: break;

// Transform individual statement nodes
// Pass SDK into statements that can produce a value
3962#define STMT(Node, Parent)                                              \
case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3964#define VALUESTMT(Node, Parent)                                         \
case Stmt::Node##Class:                                               \
  return getDerived().Transform##Node(cast<Node>(S), SDK);
3967#define ABSTRACT_STMT(Node)
3968#define EXPR(Node, Parent)
3969#include "clang/AST/StmtNodes.inc"

// Transform expressions by calling TransformExpr.
3972#define STMT(Node, Parent)
3973#define ABSTRACT_STMT(Stmt)
3974#define EXPR(Node, Parent) case Stmt::Node##Class:
3975#include "clang/AST/StmtNodes.inc"
  {
    ExprResult E = getDerived().TransformExpr(cast<Expr>(S));

    if (SDK == SDK_StmtExprResult)
      E = getSema().ActOnStmtExprResult(E);
    return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
  }
}

return S;
3986}

3988template<typename Derived>
3989OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
if (!S)
  return S;

switch (S->getClauseKind()) {
default: break;
// Transform individual clause nodes
3996#define GEN_CLANG_CLAUSE_CLASS
3997#define CLAUSE_CLASS(Enum, Str, Class)                                         \
case Enum:                                                                   \
  return getDerived().Transform##Class(cast<Class>(S));
4000#include "llvm/Frontend/OpenMP/OMP.inc"
}

return S;
4004}


4007template<typename Derived>
4008ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
if (!E)
  return E;

switch (E->getStmtClass()) {
  case Stmt::NoStmtClass: break;
4014#define STMT(Node, Parent) case Stmt::Node##Class: break;
4015#define ABSTRACT_STMT(Stmt)
4016#define EXPR(Node, Parent)                                              \
  case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4018#include "clang/AST/StmtNodes.inc"
}

return E;
4022}

4024template<typename Derived>
4025ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
                                                      bool NotCopyInit) {
// Initializers are instantiated like expressions, except that various outer
// layers are stripped.
if (!Init)
  return Init;

if (auto *FE = dyn_cast<FullExpr>(Init))
  Init = FE->getSubExpr();

if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) {
  OpaqueValueExpr *OVE = AIL->getCommonExpr();
  Init = OVE->getSourceExpr();
}

if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
  Init = MTE->getSubExpr();

while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
  Init = Binder->getSubExpr();

if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
  Init = ICE->getSubExprAsWritten();

if (CXXStdInitializerListExpr *ILE =
        dyn_cast<CXXStdInitializerListExpr>(Init))
  return TransformInitializer(ILE->getSubExpr(), NotCopyInit);

// If this is copy-initialization, we only need to reconstruct
// InitListExprs. Other forms of copy-initialization will be a no-op if
// the initializer is already the right type.
CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);
if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
  return getDerived().TransformExpr(Init);

// Revert value-initialization back to empty parens.
if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) {
  SourceRange Parens = VIE->getSourceRange();
  return getDerived().RebuildParenListExpr(Parens.getBegin(), std::nullopt,
                                           Parens.getEnd());
}

// FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
if (isa<ImplicitValueInitExpr>(Init))
  return getDerived().RebuildParenListExpr(SourceLocation(), std::nullopt,
                                           SourceLocation());

// Revert initialization by constructor back to a parenthesized or braced list
// of expressions. Any other form of initializer can just be reused directly.
if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
  return getDerived().TransformExpr(Init);

// If the initialization implicitly converted an initializer list to a
// std::initializer_list object, unwrap the std::initializer_list too.
if (Construct && Construct->isStdInitListInitialization())
  return TransformInitializer(Construct->getArg(0), NotCopyInit);

// Enter a list-init context if this was list initialization.
EnterExpressionEvaluationContext Context(
    getSema(), EnterExpressionEvaluationContext::InitList,
    Construct->isListInitialization());

SmallVector<Expr*, 8> NewArgs;
bool ArgChanged = false;
if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
                                /*IsCall*/true, NewArgs, &ArgChanged))
  return ExprError();

// If this was list initialization, revert to syntactic list form.
if (Construct->isListInitialization())
  return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs,
                                      Construct->getEndLoc());

// Build a ParenListExpr to represent anything else.
SourceRange Parens = Construct->getParenOrBraceRange();
if (Parens.isInvalid()) {
  // This was a variable declaration's initialization for which no initializer
  // was specified.
  assert(NewArgs.empty() &&(static_cast <bool> (NewArgs.empty() && "no parens or braces but have direct init with arguments?"
) ? void (0) : __assert_fail ("NewArgs.empty() && \"no parens or braces but have direct init with arguments?\""
, "clang/lib/Sema/TreeTransform.h", 4104, __extension__ __PRETTY_FUNCTION__
))
         "no parens or braces but have direct init with arguments?")(static_cast <bool> (NewArgs.empty() && "no parens or braces but have direct init with arguments?"
) ? void (0) : __assert_fail ("NewArgs.empty() && \"no parens or braces but have direct init with arguments?\""
, "clang/lib/Sema/TreeTransform.h", 4104, __extension__ __PRETTY_FUNCTION__
));
  return ExprEmpty();
}
return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
                                         Parens.getEnd());
4109}

4111template<typename Derived>
4112bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
                                          unsigned NumInputs,
                                          bool IsCall,
                                    SmallVectorImpl<Expr *> &Outputs,
                                          bool *ArgChanged) {
for (unsigned I = 0; I != NumInputs; ++I) {
  // If requested, drop call arguments that need to be dropped.
  if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
    if (ArgChanged)
      *ArgChanged = true;

    break;
  }

  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
    Expr *Pattern = Expansion->getPattern();

    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 4131, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
                                             Pattern->getSourceRange(),
                                             Unexpanded,
                                             Expand, RetainExpansion,
                                             NumExpansions))
      return true;

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      ExprResult OutPattern = getDerived().TransformExpr(Pattern);
      if (OutPattern.isInvalid())
        return true;

      ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
                                              Expansion->getEllipsisLoc(),
                                                         NumExpansions);
      if (Out.isInvalid())
        return true;

      if (ArgChanged)
        *ArgChanged = true;
      Outputs.push_back(Out.get());
      continue;
    }

    // Record right away that the argument was changed.  This needs
    // to happen even if the array expands to nothing.
    if (ArgChanged) *ArgChanged = true;

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
      ExprResult Out = getDerived().TransformExpr(Pattern);
      if (Out.isInvalid())
        return true;

      if (Out.get()->containsUnexpandedParameterPack()) {
        Out = getDerived().RebuildPackExpansion(
            Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
        if (Out.isInvalid())
          return true;
      }

      Outputs.push_back(Out.get());
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());

      ExprResult Out = getDerived().TransformExpr(Pattern);
      if (Out.isInvalid())
        return true;

      Out = getDerived().RebuildPackExpansion(
          Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
      if (Out.isInvalid())
        return true;

      Outputs.push_back(Out.get());
    }

    continue;
  }

  ExprResult Result =
    IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
           : getDerived().TransformExpr(Inputs[I]);
  if (Result.isInvalid())
    return true;

  if (Result.get() != Inputs[I] && ArgChanged)
    *ArgChanged = true;

  Outputs.push_back(Result.get());
}

return false;
4222}

4224template <typename Derived>
4225Sema::ConditionResult TreeTransform<Derived>::TransformCondition(
  SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
if (Var) {
  VarDecl *ConditionVar = cast_or_null<VarDecl>(
      getDerived().TransformDefinition(Var->getLocation(), Var));

  if (!ConditionVar)
    return Sema::ConditionError();

  return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
}

if (Expr) {
  ExprResult CondExpr = getDerived().TransformExpr(Expr);

  if (CondExpr.isInvalid())
    return Sema::ConditionError();

  return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind,
                                  /*MissingOK=*/true);
}

return Sema::ConditionResult();
4248}

4250template <typename Derived>
4251NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
  NestedNameSpecifierLoc NNS, QualType ObjectType,
  NamedDecl *FirstQualifierInScope) {
SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;

auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) {
  for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
       Qualifier = Qualifier.getPrefix())
    Qualifiers.push_back(Qualifier);
};
insertNNS(NNS);

CXXScopeSpec SS;
while (!Qualifiers.empty()) {
  NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
  NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();

  switch (QNNS->getKind()) {
  case NestedNameSpecifier::Identifier: {
    Sema::NestedNameSpecInfo IdInfo(QNNS->getAsIdentifier(),
                                    Q.getLocalBeginLoc(), Q.getLocalEndLoc(),
                                    ObjectType);
    if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, IdInfo, false,
                                            SS, FirstQualifierInScope, false))
      return NestedNameSpecifierLoc();
    break;
  }

  case NestedNameSpecifier::Namespace: {
    NamespaceDecl *NS =
        cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
            Q.getLocalBeginLoc(), QNNS->getAsNamespace()));
    SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
    break;
  }

  case NestedNameSpecifier::NamespaceAlias: {
    NamespaceAliasDecl *Alias =
        cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
            Q.getLocalBeginLoc(), QNNS->getAsNamespaceAlias()));
    SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
              Q.getLocalEndLoc());
    break;
  }

  case NestedNameSpecifier::Global:
    // There is no meaningful transformation that one could perform on the
    // global scope.
    SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
    break;

  case NestedNameSpecifier::Super: {
    CXXRecordDecl *RD =
        cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
            SourceLocation(), QNNS->getAsRecordDecl()));
    SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc());
    break;
  }

  case NestedNameSpecifier::TypeSpecWithTemplate:
  case NestedNameSpecifier::TypeSpec: {
    TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
                                            FirstQualifierInScope, SS);

    if (!TL)
      return NestedNameSpecifierLoc();

    QualType T = TL.getType();
    if (T->isDependentType() || T->isRecordType() ||
        (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) {
      if (T->isEnumeralType())
        SemaRef.Diag(TL.getBeginLoc(),
                     diag::warn_cxx98_compat_enum_nested_name_spec);

      if (const auto ETL = TL.getAs<ElaboratedTypeLoc>()) {
        SS.Adopt(ETL.getQualifierLoc());
        TL = ETL.getNamedTypeLoc();
      }
      SS.Extend(SemaRef.Context, /*FIXME:*/ SourceLocation(), TL,
                Q.getLocalEndLoc());
      break;
    }
    // If the nested-name-specifier is an invalid type def, don't emit an
    // error because a previous error should have already been emitted.
    TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>();
    if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
      SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
          << T << SS.getRange();
    }
    return NestedNameSpecifierLoc();
  }
  }

  // The qualifier-in-scope and object type only apply to the leftmost entity.
  FirstQualifierInScope = nullptr;
  ObjectType = QualType();
}

// Don't rebuild the nested-name-specifier if we don't have to.
if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
    !getDerived().AlwaysRebuild())
  return NNS;

// If we can re-use the source-location data from the original
// nested-name-specifier, do so.
if (SS.location_size() == NNS.getDataLength() &&
    memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
  return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());

// Allocate new nested-name-specifier location information.
return SS.getWithLocInContext(SemaRef.Context);
4362}

4364template<typename Derived>
4365DeclarationNameInfo
4366TreeTransform<Derived>
:TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
DeclarationName Name = NameInfo.getName();
if (!Name)
  return DeclarationNameInfo();

switch (Name.getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXOperatorName:
case DeclarationName::CXXLiteralOperatorName:
case DeclarationName::CXXUsingDirective:
  return NameInfo;

case DeclarationName::CXXDeductionGuideName: {
  TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
  TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
      getDerived().TransformDecl(NameInfo.getLoc(), OldTemplate));
  if (!NewTemplate)
    return DeclarationNameInfo();

  DeclarationNameInfo NewNameInfo(NameInfo);
  NewNameInfo.setName(
      SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(NewTemplate));
  return NewNameInfo;
}

case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
  TypeSourceInfo *NewTInfo;
  CanQualType NewCanTy;
  if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
    NewTInfo = getDerived().TransformType(OldTInfo);
    if (!NewTInfo)
      return DeclarationNameInfo();
    NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
  }
  else {
    NewTInfo = nullptr;
    TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
    QualType NewT = getDerived().TransformType(Name.getCXXNameType());
    if (NewT.isNull())
      return DeclarationNameInfo();
    NewCanTy = SemaRef.Context.getCanonicalType(NewT);
  }

  DeclarationName NewName
    = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
                                                         NewCanTy);
  DeclarationNameInfo NewNameInfo(NameInfo);
  NewNameInfo.setName(NewName);
  NewNameInfo.setNamedTypeInfo(NewTInfo);
  return NewNameInfo;
}
}

llvm_unreachable("Unknown name kind.")::llvm::llvm_unreachable_internal("Unknown name kind.", "clang/lib/Sema/TreeTransform.h"
, 4425);
4426}

4428template<typename Derived>
4429TemplateName
4430TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
                                            TemplateName Name,
                                            SourceLocation NameLoc,
                                            QualType ObjectType,
                                            NamedDecl *FirstQualifierInScope,
                                            bool AllowInjectedClassName) {
if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
  TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
  assert(Template && "qualified template name must refer to a template")(static_cast <bool> (Template && "qualified template name must refer to a template"
) ? void (0) : __assert_fail ("Template && \"qualified template name must refer to a template\""
, "clang/lib/Sema/TreeTransform.h", 4438, __extension__ __PRETTY_FUNCTION__
));

  TemplateDecl *TransTemplate
    = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
                                                            Template));
  if (!TransTemplate)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      SS.getScopeRep() == QTN->getQualifier() &&
      TransTemplate == Template)
    return Name;

  return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
                                          TransTemplate);
}

if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
  if (SS.getScopeRep()) {
    // These apply to the scope specifier, not the template.
    ObjectType = QualType();
    FirstQualifierInScope = nullptr;
  }

  if (!getDerived().AlwaysRebuild() &&
      SS.getScopeRep() == DTN->getQualifier() &&
      ObjectType.isNull())
    return Name;

  // FIXME: Preserve the location of the "template" keyword.
  SourceLocation TemplateKWLoc = NameLoc;

  if (DTN->isIdentifier()) {
    return getDerived().RebuildTemplateName(SS,
                                            TemplateKWLoc,
                                            *DTN->getIdentifier(),
                                            NameLoc,
                                            ObjectType,
                                            FirstQualifierInScope,
                                            AllowInjectedClassName);
  }

  return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
                                          DTN->getOperator(), NameLoc,
                                          ObjectType, AllowInjectedClassName);
}

if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
  TemplateDecl *TransTemplate
    = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
                                                            Template));
  if (!TransTemplate)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      TransTemplate == Template)
    return Name;

  return TemplateName(TransTemplate);
}

if (SubstTemplateTemplateParmPackStorage *SubstPack
    = Name.getAsSubstTemplateTemplateParmPack()) {
  return getDerived().RebuildTemplateName(
      SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
      SubstPack->getIndex(), SubstPack->getFinal());
}

// These should be getting filtered out before they reach the AST.
llvm_unreachable("overloaded function decl survived to here")::llvm::llvm_unreachable_internal("overloaded function decl survived to here"
, "clang/lib/Sema/TreeTransform.h", 4507);
4508}

4510template<typename Derived>
4511void TreeTransform<Derived>::InventTemplateArgumentLoc(
                                       const TemplateArgument &Arg,
                                       TemplateArgumentLoc &Output) {
Output = getSema().getTrivialTemplateArgumentLoc(
    Arg, QualType(), getDerived().getBaseLocation());
4516}

4518template <typename Derived>
4519bool TreeTransform<Derived>::TransformTemplateArgument(
  const TemplateArgumentLoc &Input, TemplateArgumentLoc &Output,
  bool Uneval) {
const TemplateArgument &Arg = Input.getArgument();
switch (Arg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Pack:
  llvm_unreachable("Unexpected TemplateArgument")::llvm::llvm_unreachable_internal("Unexpected TemplateArgument"
, "clang/lib/Sema/TreeTransform.h", 4526);

case TemplateArgument::Integral:
case TemplateArgument::NullPtr:
case TemplateArgument::Declaration: {
  // Transform a resolved template argument straight to a resolved template
  // argument. We get here when substituting into an already-substituted
  // template type argument during concept satisfaction checking.
  QualType T = Arg.getNonTypeTemplateArgumentType();
  QualType NewT = getDerived().TransformType(T);
  if (NewT.isNull())
    return true;

  ValueDecl *D = Arg.getKind() == TemplateArgument::Declaration
                     ? Arg.getAsDecl()
                     : nullptr;
  ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
                            getDerived().getBaseLocation(), D))
                      : nullptr;
  if (D && !NewD)
    return true;

  if (NewT == T && D == NewD)
    Output = Input;
  else if (Arg.getKind() == TemplateArgument::Integral)
    Output = TemplateArgumentLoc(
        TemplateArgument(getSema().Context, Arg.getAsIntegral(), NewT),
        TemplateArgumentLocInfo());
  else if (Arg.getKind() == TemplateArgument::NullPtr)
    Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
                                 TemplateArgumentLocInfo());
  else
    Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT),
                                 TemplateArgumentLocInfo());

  return false;
}

case TemplateArgument::Type: {
  TypeSourceInfo *DI = Input.getTypeSourceInfo();
  if (!DI)
    DI = InventTypeSourceInfo(Input.getArgument().getAsType());

  DI = getDerived().TransformType(DI);
  if (!DI)
    return true;

  Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
  return false;
}

case TemplateArgument::Template: {
  NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
  if (QualifierLoc) {
    QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
    if (!QualifierLoc)
      return true;
  }

  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  TemplateName Template = getDerived().TransformTemplateName(
      SS, Arg.getAsTemplate(), Input.getTemplateNameLoc());
  if (Template.isNull())
    return true;

  Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
                               QualifierLoc, Input.getTemplateNameLoc());
  return false;
}

case TemplateArgument::TemplateExpansion:
  llvm_unreachable("Caller should expand pack expansions")::llvm::llvm_unreachable_internal("Caller should expand pack expansions"
, "clang/lib/Sema/TreeTransform.h", 4598);

case TemplateArgument::Expression: {
  // Template argument expressions are constant expressions.
  EnterExpressionEvaluationContext Unevaluated(
      getSema(),
      Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
             : Sema::ExpressionEvaluationContext::ConstantEvaluated,
      Sema::ReuseLambdaContextDecl, /*ExprContext=*/
      Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);

  Expr *InputExpr = Input.getSourceExpression();
  if (!InputExpr)
    InputExpr = Input.getArgument().getAsExpr();

  ExprResult E = getDerived().TransformExpr(InputExpr);
  E = SemaRef.ActOnConstantExpression(E);
  if (E.isInvalid())
    return true;
  Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
  return false;
}
}

// Work around bogus GCC warning
return true;
4624}

4626/// Iterator adaptor that invents template argument location information
4627/// for each of the template arguments in its underlying iterator.
4628template<typename Derived, typename InputIterator>
4629class TemplateArgumentLocInventIterator {
TreeTransform<Derived> &Self;
InputIterator Iter;

4633public:
typedef TemplateArgumentLoc value_type;
typedef TemplateArgumentLoc reference;
typedef typename std::iterator_traits<InputIterator>::difference_type
  difference_type;
typedef std::input_iterator_tag iterator_category;

class pointer {
  TemplateArgumentLoc Arg;

public:
  explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }

  const TemplateArgumentLoc *operator->() const { return &Arg; }
};

TemplateArgumentLocInventIterator() { }

explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
                                           InputIterator Iter)
  : Self(Self), Iter(Iter) { }

TemplateArgumentLocInventIterator &operator++() {
  ++Iter;
  return *this;
}

TemplateArgumentLocInventIterator operator++(int) {
  TemplateArgumentLocInventIterator Old(*this);
  ++(*this);
  return Old;
}

reference operator*() const {
  TemplateArgumentLoc Result;
  Self.InventTemplateArgumentLoc(*Iter, Result);
  return Result;
}

pointer operator->() const { return pointer(**this); }

friend bool operator==(const TemplateArgumentLocInventIterator &X,
                       const TemplateArgumentLocInventIterator &Y) {
  return X.Iter == Y.Iter;
}

friend bool operator!=(const TemplateArgumentLocInventIterator &X,
                       const TemplateArgumentLocInventIterator &Y) {
  return X.Iter != Y.Iter;
}
4683};

4685template<typename Derived>
4686template<typename InputIterator>
4687bool TreeTransform<Derived>::TransformTemplateArguments(
  InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
  bool Uneval) {
for (; First != Last; ++First) {
  TemplateArgumentLoc Out;
  TemplateArgumentLoc In = *First;

  if (In.getArgument().getKind() == TemplateArgument::Pack) {
    // Unpack argument packs, which we translate them into separate
    // arguments.
    // FIXME: We could do much better if we could guarantee that the
    // TemplateArgumentLocInfo for the pack expansion would be usable for
    // all of the template arguments in the argument pack.
    typedef TemplateArgumentLocInventIterator<Derived,
                                              TemplateArgument::pack_iterator>
      PackLocIterator;
    if (TransformTemplateArguments(PackLocIterator(*this,
                                               In.getArgument().pack_begin()),
                                   PackLocIterator(*this,
                                                 In.getArgument().pack_end()),
                                   Outputs, Uneval))
      return true;

    continue;
  }

  if (In.getArgument().isPackExpansion()) {
    // We have a pack expansion, for which we will be substituting into
    // the pattern.
    SourceLocation Ellipsis;
    std::optional<unsigned> OrigNumExpansions;
    TemplateArgumentLoc Pattern
      = getSema().getTemplateArgumentPackExpansionPattern(
            In, Ellipsis, OrigNumExpansions);

    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 4724, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(Ellipsis,
                                             Pattern.getSourceRange(),
                                             Unexpanded,
                                             Expand,
                                             RetainExpansion,
                                             NumExpansions))
      return true;

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      TemplateArgumentLoc OutPattern;
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
        return true;

      Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
                                              NumExpansions);
      if (Out.getArgument().isNull())
        return true;

      Outputs.addArgument(Out);
      continue;
    }

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);

      if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
        return true;

      if (Out.getArgument().containsUnexpandedParameterPack()) {
        Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
                                                OrigNumExpansions);
        if (Out.getArgument().isNull())
          return true;
      }

      Outputs.addArgument(Out);
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());

      if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
        return true;

      Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
                                              OrigNumExpansions);
      if (Out.getArgument().isNull())
        return true;

      Outputs.addArgument(Out);
    }

    continue;
  }

  // The simple case:
  if (getDerived().TransformTemplateArgument(In, Out, Uneval))
    return true;

  Outputs.addArgument(Out);
}

return false;

4803}

4805//===----------------------------------------------------------------------===//
4806// Type transformation
4807//===----------------------------------------------------------------------===//

4809template<typename Derived>
4810QualType TreeTransform<Derived>::TransformType(QualType T) {
if (getDerived().AlreadyTransformed(T))
  return T;

// Temporary workaround.  All of these transformations should
// eventually turn into transformations on TypeLocs.
TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
                                              getDerived().getBaseLocation());

TypeSourceInfo *NewDI = getDerived().TransformType(DI);

if (!NewDI)
  return QualType();

return NewDI->getType();
4825}

4827template<typename Derived>
4828TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) {
// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
                     getDerived().getBaseEntity());
if (getDerived().AlreadyTransformed(DI->getType()))
13
←
Taking false branch→
18
←
Taking false branch→
  return DI;

TypeLocBuilder TLB;

TypeLoc TL = DI->getTypeLoc();
TLB.reserve(TL.getFullDataSize());

QualType Result = getDerived().TransformType(TLB, TL);
14
←
Calling 'TreeTransform::TransformType'→
if (Result.isNull())
19
←
Taking false branch→
  return nullptr;

return TLB.getTypeSourceInfo(SemaRef.Context, Result);
20
←
Returning pointer, which participates in a condition later→
4845}

4847template<typename Derived>
4848QualType
4849TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
switch (T.getTypeLocClass()) {
15
←
Control jumps to 'case TypeOf:'  at line 74→
4851#define ABSTRACT_TYPELOC(CLASS, PARENT)
4852#define TYPELOC(CLASS, PARENT)                                                 \
case TypeLoc::CLASS:                                                         \
  return getDerived().Transform##CLASS##Type(TLB,                            \
                                             T.castAs<CLASS##TypeLoc>());
4856#include "clang/AST/TypeLocNodes.def"
}

llvm_unreachable("unhandled type loc!")::llvm::llvm_unreachable_internal("unhandled type loc!", "clang/lib/Sema/TreeTransform.h"
, 4859);
4860}

4862template<typename Derived>
4863QualType TreeTransform<Derived>::TransformTypeWithDeducedTST(QualType T) {
if (!isa<DependentNameType>(T))
  return TransformType(T);

if (getDerived().AlreadyTransformed(T))
  return T;
TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
                                              getDerived().getBaseLocation());
TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
return NewDI ? NewDI->getType() : QualType();
4873}

4875template<typename Derived>
4876TypeSourceInfo *
4877TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *DI) {
if (!isa<DependentNameType>(DI->getType()))
  return TransformType(DI);

// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
                     getDerived().getBaseEntity());
if (getDerived().AlreadyTransformed(DI->getType()))
  return DI;

TypeLocBuilder TLB;

TypeLoc TL = DI->getTypeLoc();
TLB.reserve(TL.getFullDataSize());

auto QTL = TL.getAs<QualifiedTypeLoc>();
if (QTL)
  TL = QTL.getUnqualifiedLoc();

auto DNTL = TL.castAs<DependentNameTypeLoc>();

QualType Result = getDerived().TransformDependentNameType(
    TLB, DNTL, /*DeducedTSTContext*/true);
if (Result.isNull())
  return nullptr;

if (QTL) {
  Result = getDerived().RebuildQualifiedType(Result, QTL);
  if (Result.isNull())
    return nullptr;
  TLB.TypeWasModifiedSafely(Result);
}

return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4911}

4913template<typename Derived>
4914QualType
4915TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
                                             QualifiedTypeLoc T) {
QualType Result;
TypeLoc UnqualTL = T.getUnqualifiedLoc();
auto SuppressObjCLifetime =
    T.getType().getLocalQualifiers().hasObjCLifetime();
if (auto TTP = UnqualTL.getAs<TemplateTypeParmTypeLoc>()) {
  Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
                                                      SuppressObjCLifetime);
} else if (auto STTP = UnqualTL.getAs<SubstTemplateTypeParmPackTypeLoc>()) {
  Result = getDerived().TransformSubstTemplateTypeParmPackType(
      TLB, STTP, SuppressObjCLifetime);
} else {
  Result = getDerived().TransformType(TLB, UnqualTL);
}

if (Result.isNull())
  return QualType();

Result = getDerived().RebuildQualifiedType(Result, T);

if (Result.isNull())
  return QualType();

// RebuildQualifiedType might have updated the type, but not in a way
// that invalidates the TypeLoc. (There's no location information for
// qualifiers.)
TLB.TypeWasModifiedSafely(Result);

return Result;
4945}

4947template <typename Derived>
4948QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
                                                    QualifiedTypeLoc TL) {

SourceLocation Loc = TL.getBeginLoc();
Qualifiers Quals = TL.getType().getLocalQualifiers();

if ((T.getAddressSpace() != LangAS::Default &&
     Quals.getAddressSpace() != LangAS::Default) &&
    T.getAddressSpace() != Quals.getAddressSpace()) {
  SemaRef.Diag(Loc, diag::err_address_space_mismatch_templ_inst)
      << TL.getType() << T;
  return QualType();
}

// C++ [dcl.fct]p7:
//   [When] adding cv-qualifications on top of the function type [...] the
//   cv-qualifiers are ignored.
if (T->isFunctionType()) {
  T = SemaRef.getASTContext().getAddrSpaceQualType(T,
                                                   Quals.getAddressSpace());
  return T;
}

// C++ [dcl.ref]p1:
//   when the cv-qualifiers are introduced through the use of a typedef-name
//   or decltype-specifier [...] the cv-qualifiers are ignored.
// Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be
// applied to a reference type.
if (T->isReferenceType()) {
  // The only qualifier that applies to a reference type is restrict.
  if (!Quals.hasRestrict())
    return T;
  Quals = Qualifiers::fromCVRMask(Qualifiers::Restrict);
}

// Suppress Objective-C lifetime qualifiers if they don't make sense for the
// resulting type.
if (Quals.hasObjCLifetime()) {
  if (!T->isObjCLifetimeType() && !T->isDependentType())
    Quals.removeObjCLifetime();
  else if (T.getObjCLifetime()) {
    // Objective-C ARC:
    //   A lifetime qualifier applied to a substituted template parameter
    //   overrides the lifetime qualifier from the template argument.
    const AutoType *AutoTy;
    if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
      // 'auto' types behave the same way as template parameters.
      QualType Deduced = AutoTy->getDeducedType();
      Qualifiers Qs = Deduced.getQualifiers();
      Qs.removeObjCLifetime();
      Deduced =
          SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), Qs);
      T = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
                                      AutoTy->isDependentType(),
                                      /*isPack=*/false,
                                      AutoTy->getTypeConstraintConcept(),
                                      AutoTy->getTypeConstraintArguments());
    } else {
      // Otherwise, complain about the addition of a qualifier to an
      // already-qualified type.
      // FIXME: Why is this check not in Sema::BuildQualifiedType?
      SemaRef.Diag(Loc, diag::err_attr_objc_ownership_redundant) << T;
      Quals.removeObjCLifetime();
    }
  }
}

return SemaRef.BuildQualifiedType(T, Loc, Quals);
5016}

5018template<typename Derived>
5019TypeLoc
5020TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
                                                 QualType ObjectType,
                                                 NamedDecl *UnqualLookup,
                                                 CXXScopeSpec &SS) {
if (getDerived().AlreadyTransformed(TL.getType()))
  return TL;

TypeSourceInfo *TSI =
    TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
if (TSI)
  return TSI->getTypeLoc();
return TypeLoc();
5032}

5034template<typename Derived>
5035TypeSourceInfo *
5036TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                                 QualType ObjectType,
                                                 NamedDecl *UnqualLookup,
                                                 CXXScopeSpec &SS) {
if (getDerived().AlreadyTransformed(TSInfo->getType()))
  return TSInfo;

return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
                                 UnqualLookup, SS);
5045}

5047template <typename Derived>
5048TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
  TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
  CXXScopeSpec &SS) {
QualType T = TL.getType();
assert(!getDerived().AlreadyTransformed(T))(static_cast <bool> (!getDerived().AlreadyTransformed(T
)) ? void (0) : __assert_fail ("!getDerived().AlreadyTransformed(T)"
, "clang/lib/Sema/TreeTransform.h", 5052, __extension__ __PRETTY_FUNCTION__
));

TypeLocBuilder TLB;
QualType Result;

if (isa<TemplateSpecializationType>(T)) {
  TemplateSpecializationTypeLoc SpecTL =
      TL.castAs<TemplateSpecializationTypeLoc>();

  TemplateName Template = getDerived().TransformTemplateName(
      SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
      ObjectType, UnqualLookup, /*AllowInjectedClassName*/true);
  if (Template.isNull())
    return nullptr;

  Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
                                                            Template);
} else if (isa<DependentTemplateSpecializationType>(T)) {
  DependentTemplateSpecializationTypeLoc SpecTL =
      TL.castAs<DependentTemplateSpecializationTypeLoc>();

  TemplateName Template
    = getDerived().RebuildTemplateName(SS,
                                       SpecTL.getTemplateKeywordLoc(),
                                       *SpecTL.getTypePtr()->getIdentifier(),
                                       SpecTL.getTemplateNameLoc(),
                                       ObjectType, UnqualLookup,
                                       /*AllowInjectedClassName*/true);
  if (Template.isNull())
    return nullptr;

  Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
                                                                     SpecTL,
                                                                     Template,
                                                                     SS);
} else {
  // Nothing special needs to be done for these.
  Result = getDerived().TransformType(TLB, TL);
}

if (Result.isNull())
  return nullptr;

return TLB.getTypeSourceInfo(SemaRef.Context, Result);
5096}

5098template <class TyLoc> static inline
5099QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
TyLoc NewT = TLB.push<TyLoc>(T.getType());
NewT.setNameLoc(T.getNameLoc());
return T.getType();
5103}

5105template<typename Derived>
5106QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
                                                    BuiltinTypeLoc T) {
BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
NewT.setBuiltinLoc(T.getBuiltinLoc());
if (T.needsExtraLocalData())
  NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
return T.getType();
5113}

5115template<typename Derived>
5116QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
                                                    ComplexTypeLoc T) {
// FIXME: recurse?
return TransformTypeSpecType(TLB, T);
5120}

5122template <typename Derived>
5123QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
                                                     AdjustedTypeLoc TL) {
// Adjustments applied during transformation are handled elsewhere.
return getDerived().TransformType(TLB, TL.getOriginalLoc());
5127}

5129template<typename Derived>
5130QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
                                                    DecayedTypeLoc TL) {
QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
if (OriginalType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    OriginalType != TL.getOriginalLoc().getType())
  Result = SemaRef.Context.getDecayedType(OriginalType);
TLB.push<DecayedTypeLoc>(Result);
// Nothing to set for DecayedTypeLoc.
return Result;
5143}

5145template<typename Derived>
5146QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
                                                    PointerTypeLoc TL) {
QualType PointeeType
  = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (PointeeType->getAs<ObjCObjectType>()) {
  // A dependent pointer type 'T *' has is being transformed such
  // that an Objective-C class type is being replaced for 'T'. The
  // resulting pointer type is an ObjCObjectPointerType, not a
  // PointerType.
  Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);

  ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
  NewT.setStarLoc(TL.getStarLoc());
  return Result;
}

if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

// Objective-C ARC can add lifetime qualifiers to the type that we're
// pointing to.
TLB.TypeWasModifiedSafely(Result->getPointeeType());

PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
NewT.setSigilLoc(TL.getSigilLoc());
return Result;
5180}

5182template<typename Derived>
5183QualType
5184TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
                                                BlockPointerTypeLoc TL) {
QualType PointeeType
  = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildBlockPointerType(PointeeType,
                                                TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
NewT.setSigilLoc(TL.getSigilLoc());
return Result;
5203}

5205/// Transforms a reference type.  Note that somewhat paradoxically we
5206/// don't care whether the type itself is an l-value type or an r-value
5207/// type;  we only care if the type was *written* as an l-value type
5208/// or an r-value type.
5209template<typename Derived>
5210QualType
5211TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
                                             ReferenceTypeLoc TL) {
const ReferenceType *T = TL.getTypePtr();

// Note that this works with the pointee-as-written.
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != T->getPointeeTypeAsWritten()) {
  Result = getDerived().RebuildReferenceType(PointeeType,
                                             T->isSpelledAsLValue(),
                                             TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

// Objective-C ARC can add lifetime qualifiers to the type that we're
// referring to.
TLB.TypeWasModifiedSafely(
    Result->castAs<ReferenceType>()->getPointeeTypeAsWritten());

// r-value references can be rebuilt as l-value references.
ReferenceTypeLoc NewTL;
if (isa<LValueReferenceType>(Result))
  NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
else
  NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());

return Result;
5244}

5246template<typename Derived>
5247QualType
5248TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
                                               LValueReferenceTypeLoc TL) {
return TransformReferenceType(TLB, TL);
5251}

5253template<typename Derived>
5254QualType
5255TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
                                               RValueReferenceTypeLoc TL) {
return TransformReferenceType(TLB, TL);
5258}

5260template<typename Derived>
5261QualType
5262TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
                                                 MemberPointerTypeLoc TL) {
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
TypeSourceInfo *NewClsTInfo = nullptr;
if (OldClsTInfo) {
  NewClsTInfo = getDerived().TransformType(OldClsTInfo);
  if (!NewClsTInfo)
    return QualType();
}

const MemberPointerType *T = TL.getTypePtr();
QualType OldClsType = QualType(T->getClass(), 0);
QualType NewClsType;
if (NewClsTInfo)
  NewClsType = NewClsTInfo->getType();
else {
  NewClsType = getDerived().TransformType(OldClsType);
  if (NewClsType.isNull())
    return QualType();
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != T->getPointeeType() ||
    NewClsType != OldClsType) {
  Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
                                                 TL.getStarLoc());
  if (Result.isNull())
    return QualType();
}

// If we had to adjust the pointee type when building a member pointer, make
// sure to push TypeLoc info for it.
const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
if (MPT && PointeeType != MPT->getPointeeType()) {
  assert(isa<AdjustedType>(MPT->getPointeeType()))(static_cast <bool> (isa<AdjustedType>(MPT->getPointeeType
())) ? void (0) : __assert_fail ("isa<AdjustedType>(MPT->getPointeeType())"
, "clang/lib/Sema/TreeTransform.h", 5301, __extension__ __PRETTY_FUNCTION__
));
  TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
}

MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());
NewTL.setClassTInfo(NewClsTInfo);

return Result;
5310}

5312template<typename Derived>
5313QualType
5314TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
                                                 ConstantArrayTypeLoc TL) {
const ConstantArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Prefer the expression from the TypeLoc;  the other may have been uniqued.
Expr *OldSize = TL.getSizeExpr();
if (!OldSize)
  OldSize = const_cast<Expr*>(T->getSizeExpr());
Expr *NewSize = nullptr;
if (OldSize) {
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>();
  NewSize = SemaRef.ActOnConstantExpression(NewSize).get();
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    (T->getSizeExpr() && NewSize != OldSize)) {
  Result = getDerived().RebuildConstantArrayType(ElementType,
                                                 T->getSizeModifier(),
                                                 T->getSize(), NewSize,
                                           T->getIndexTypeCVRQualifiers(),
                                                 TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have either a ConstantArrayType or a VariableArrayType now:
// a ConstantArrayType is allowed to have an element type which is a
// VariableArrayType if the type is dependent.  Fortunately, all array
// types have the same location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(NewSize);

return Result;
5356}

5358template<typename Derived>
5359QualType TreeTransform<Derived>::TransformIncompleteArrayType(
                                            TypeLocBuilder &TLB,
                                            IncompleteArrayTypeLoc TL) {
const IncompleteArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildIncompleteArrayType(ElementType,
                                                   T->getSizeModifier(),
                                         T->getIndexTypeCVRQualifiers(),
                                                   TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(nullptr);

return Result;
5384}

5386template<typename Derived>
5387QualType
5388TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
                                                 VariableArrayTypeLoc TL) {
const VariableArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

ExprResult SizeResult;
{
  EnterExpressionEvaluationContext Context(
      SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
  SizeResult = getDerived().TransformExpr(T->getSizeExpr());
}
if (SizeResult.isInvalid())
  return QualType();
SizeResult =
    SemaRef.ActOnFinishFullExpr(SizeResult.get(), /*DiscardedValue*/ false);
if (SizeResult.isInvalid())
  return QualType();

Expr *Size = SizeResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    Size != T->getSizeExpr()) {
  Result = getDerived().RebuildVariableArrayType(ElementType,
                                                 T->getSizeModifier(),
                                                 Size,
                                           T->getIndexTypeCVRQualifiers(),
                                                 TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have constant size array now, but fortunately it has the same
// location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(Size);

return Result;
5431}

5433template<typename Derived>
5434QualType
5435TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
                                           DependentSizedArrayTypeLoc TL) {
const DependentSizedArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Array bounds are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

// Prefer the expression from the TypeLoc;  the other may have been uniqued.
Expr *origSize = TL.getSizeExpr();
if (!origSize) origSize = T->getSizeExpr();

ExprResult sizeResult
  = getDerived().TransformExpr(origSize);
sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
if (sizeResult.isInvalid())
  return QualType();

Expr *size = sizeResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    size != origSize) {
  Result = getDerived().RebuildDependentSizedArrayType(ElementType,
                                                       T->getSizeModifier(),
                                                       size,
                                              T->getIndexTypeCVRQualifiers(),
                                                      TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have any sort of array type now, but fortunately they
// all have the same location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(size);

return Result;
5479}

5481template <typename Derived>
5482QualType TreeTransform<Derived>::TransformDependentVectorType(
  TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
const DependentVectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
Size = SemaRef.ActOnConstantExpression(Size);
if (Size.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
    Size.get() != T->getSizeExpr()) {
  Result = getDerived().RebuildDependentVectorType(
      ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentVectorType>(Result)) {
  DependentVectorTypeLoc NewTL =
      TLB.push<DependentVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}

return Result;
5517}

5519template<typename Derived>
5520QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
                                    TypeLocBuilder &TLB,
                                    DependentSizedExtVectorTypeLoc TL) {
const DependentSizedExtVectorType *T = TL.getTypePtr();

// FIXME: ext vector locs should be nested
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Vector sizes are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
Size = SemaRef.ActOnConstantExpression(Size);
if (Size.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    Size.get() != T->getSizeExpr()) {
  Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
                                                           Size.get(),
                                                       T->getAttributeLoc());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentSizedExtVectorType>(Result)) {
  DependentSizedExtVectorTypeLoc NewTL
    = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}

return Result;
5561}

5563template <typename Derived>
5564QualType
5565TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
                                                  ConstantMatrixTypeLoc TL) {
const ConstantMatrixType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) {
  Result = getDerived().RebuildConstantMatrixType(
      ElementType, T->getNumRows(), T->getNumColumns());
  if (Result.isNull())
    return QualType();
}

ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(Result);
NewTL.setAttrNameLoc(TL.getAttrNameLoc());
NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
NewTL.setAttrRowOperand(TL.getAttrRowOperand());
NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());

return Result;
5587}

5589template <typename Derived>
5590QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
  TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
const DependentSizedMatrixType *T = TL.getTypePtr();

QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull()) {
  return QualType();
}

// Matrix dimensions are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

Expr *origRows = TL.getAttrRowOperand();
if (!origRows)
  origRows = T->getRowExpr();
Expr *origColumns = TL.getAttrColumnOperand();
if (!origColumns)
  origColumns = T->getColumnExpr();

ExprResult rowResult = getDerived().TransformExpr(origRows);
rowResult = SemaRef.ActOnConstantExpression(rowResult);
if (rowResult.isInvalid())
  return QualType();

ExprResult columnResult = getDerived().TransformExpr(origColumns);
columnResult = SemaRef.ActOnConstantExpression(columnResult);
if (columnResult.isInvalid())
  return QualType();

Expr *rows = rowResult.get();
Expr *columns = columnResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
    rows != origRows || columns != origColumns) {
  Result = getDerived().RebuildDependentSizedMatrixType(
      ElementType, rows, columns, T->getAttributeLoc());

  if (Result.isNull())
    return QualType();
}

// We might have any sort of matrix type now, but fortunately they
// all have the same location layout.
MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(Result);
NewTL.setAttrNameLoc(TL.getAttrNameLoc());
NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
NewTL.setAttrRowOperand(rows);
NewTL.setAttrColumnOperand(columns);
return Result;
5641}

5643template <typename Derived>
5644QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
  TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
const DependentAddressSpaceType *T = TL.getTypePtr();

QualType pointeeType = getDerived().TransformType(T->getPointeeType());

if (pointeeType.isNull())
  return QualType();

// Address spaces are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
AddrSpace = SemaRef.ActOnConstantExpression(AddrSpace);
if (AddrSpace.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
    AddrSpace.get() != T->getAddrSpaceExpr()) {
  Result = getDerived().RebuildDependentAddressSpaceType(
      pointeeType, AddrSpace.get(), T->getAttributeLoc());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentAddressSpaceType>(Result)) {
  DependentAddressSpaceTypeLoc NewTL =
      TLB.push<DependentAddressSpaceTypeLoc>(Result);

  NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
  NewTL.setAttrExprOperand(TL.getAttrExprOperand());
  NewTL.setAttrNameLoc(TL.getAttrNameLoc());

} else {
  TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
      Result, getDerived().getBaseLocation());
  TransformType(TLB, DI->getTypeLoc());
}

return Result;
5687}

5689template <typename Derived>
5690QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
                                                   VectorTypeLoc TL) {
const VectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
                                          T->getVectorKind());
  if (Result.isNull())
    return QualType();
}

VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5710}

5712template<typename Derived>
5713QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
                                                      ExtVectorTypeLoc TL) {
const VectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildExtVectorType(ElementType,
                                             T->getNumElements(),
                                             /*FIXME*/ SourceLocation());
  if (Result.isNull())
    return QualType();
}

ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5734}

5736template <typename Derived>
5737ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
  ParmVarDecl *OldParm, int indexAdjustment,
  std::optional<unsigned> NumExpansions, bool ExpectParameterPack) {
TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
TypeSourceInfo *NewDI = nullptr;

if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
  // If we're substituting into a pack expansion type and we know the
  // length we want to expand to, just substitute for the pattern.
  TypeLoc OldTL = OldDI->getTypeLoc();
  PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();

  TypeLocBuilder TLB;
  TypeLoc NewTL = OldDI->getTypeLoc();
  TLB.reserve(NewTL.getFullDataSize());

  QualType Result = getDerived().TransformType(TLB,
                                             OldExpansionTL.getPatternLoc());
  if (Result.isNull())
    return nullptr;

  Result = RebuildPackExpansionType(Result,
                              OldExpansionTL.getPatternLoc().getSourceRange(),
                                    OldExpansionTL.getEllipsisLoc(),
                                    NumExpansions);
  if (Result.isNull())
    return nullptr;

  PackExpansionTypeLoc NewExpansionTL
    = TLB.push<PackExpansionTypeLoc>(Result);
  NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
  NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
} else
  NewDI = getDerived().TransformType(OldDI);
if (!NewDI)
  return nullptr;

if (NewDI == OldDI && indexAdjustment == 0)
  return OldParm;

ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context,
                                           OldParm->getDeclContext(),
                                           OldParm->getInnerLocStart(),
                                           OldParm->getLocation(),
                                           OldParm->getIdentifier(),
                                           NewDI->getType(),
                                           NewDI,
                                           OldParm->getStorageClass(),
                                           /* DefArg */ nullptr);
newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
                      OldParm->getFunctionScopeIndex() + indexAdjustment);
transformedLocalDecl(OldParm, {newParm});
return newParm;
5790}

5792template <typename Derived>
5793bool TreeTransform<Derived>::TransformFunctionTypeParams(
  SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
  const QualType *ParamTypes,
  const FunctionProtoType::ExtParameterInfo *ParamInfos,
  SmallVectorImpl<QualType> &OutParamTypes,
  SmallVectorImpl<ParmVarDecl *> *PVars,
  Sema::ExtParameterInfoBuilder &PInfos,
  unsigned *LastParamTransformed) {
int indexAdjustment = 0;

unsigned NumParams = Params.size();
for (unsigned i = 0; i != NumParams; ++i) {
  if (LastParamTransformed)
    *LastParamTransformed = i;
  if (ParmVarDecl *OldParm = Params[i]) {
    assert(OldParm->getFunctionScopeIndex() == i)(static_cast <bool> (OldParm->getFunctionScopeIndex(
) == i) ? void (0) : __assert_fail ("OldParm->getFunctionScopeIndex() == i"
, "clang/lib/Sema/TreeTransform.h", 5808, __extension__ __PRETTY_FUNCTION__
));

    std::optional<unsigned> NumExpansions;
    ParmVarDecl *NewParm = nullptr;
    if (OldParm->isParameterPack()) {
      // We have a function parameter pack that may need to be expanded.
      SmallVector<UnexpandedParameterPack, 2> Unexpanded;

      // Find the parameter packs that could be expanded.
      TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
      PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
      TypeLoc Pattern = ExpansionTL.getPatternLoc();
      SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);

      // Determine whether we should expand the parameter packs.
      bool ShouldExpand = false;
      bool RetainExpansion = false;
      std::optional<unsigned> OrigNumExpansions;
      if (Unexpanded.size() > 0) {
        OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
        NumExpansions = OrigNumExpansions;
        if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                                 Pattern.getSourceRange(),
                                                 Unexpanded,
                                                 ShouldExpand,
                                                 RetainExpansion,
                                                 NumExpansions)) {
          return true;
        }
      } else {
5838#ifndef NDEBUG
        const AutoType *AT =
            Pattern.getType().getTypePtr()->getContainedAutoType();
        assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) &&(static_cast <bool> ((AT && (!AT->isDeduced(
) || AT->getDeducedType().isNull())) && "Could not find parameter packs or undeduced auto type!"
) ? void (0) : __assert_fail ("(AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) && \"Could not find parameter packs or undeduced auto type!\""
, "clang/lib/Sema/TreeTransform.h", 5842, __extension__ __PRETTY_FUNCTION__
))
               "Could not find parameter packs or undeduced auto type!")(static_cast <bool> ((AT && (!AT->isDeduced(
) || AT->getDeducedType().isNull())) && "Could not find parameter packs or undeduced auto type!"
) ? void (0) : __assert_fail ("(AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) && \"Could not find parameter packs or undeduced auto type!\""
, "clang/lib/Sema/TreeTransform.h", 5842, __extension__ __PRETTY_FUNCTION__
));
5843#endif
      }

      if (ShouldExpand) {
        // Expand the function parameter pack into multiple, separate
        // parameters.
        getDerived().ExpandingFunctionParameterPack(OldParm);
        for (unsigned I = 0; I != *NumExpansions; ++I) {
          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
          ParmVarDecl *NewParm
            = getDerived().TransformFunctionTypeParam(OldParm,
                                                      indexAdjustment++,
                                                      OrigNumExpansions,
                                              /*ExpectParameterPack=*/false);
          if (!NewParm)
            return true;

          if (ParamInfos)
            PInfos.set(OutParamTypes.size(), ParamInfos[i]);
          OutParamTypes.push_back(NewParm->getType());
          if (PVars)
            PVars->push_back(NewParm);
        }

        // If we're supposed to retain a pack expansion, do so by temporarily
        // forgetting the partially-substituted parameter pack.
        if (RetainExpansion) {
          ForgetPartiallySubstitutedPackRAII Forget(getDerived());
          ParmVarDecl *NewParm
            = getDerived().TransformFunctionTypeParam(OldParm,
                                                      indexAdjustment++,
                                                      OrigNumExpansions,
                                              /*ExpectParameterPack=*/false);
          if (!NewParm)
            return true;

          if (ParamInfos)
            PInfos.set(OutParamTypes.size(), ParamInfos[i]);
          OutParamTypes.push_back(NewParm->getType());
          if (PVars)
            PVars->push_back(NewParm);
        }

        // The next parameter should have the same adjustment as the
        // last thing we pushed, but we post-incremented indexAdjustment
        // on every push.  Also, if we push nothing, the adjustment should
        // go down by one.
        indexAdjustment--;

        // We're done with the pack expansion.
        continue;
      }

      // We'll substitute the parameter now without expanding the pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      NewParm = getDerived().TransformFunctionTypeParam(OldParm,
                                                        indexAdjustment,
                                                        NumExpansions,
                                                /*ExpectParameterPack=*/true);
      assert(NewParm->isParameterPack() &&(static_cast <bool> (NewParm->isParameterPack() &&
 "Parameter pack no longer a parameter pack after " "transformation."
) ? void (0) : __assert_fail ("NewParm->isParameterPack() && \"Parameter pack no longer a parameter pack after \" \"transformation.\""
, "clang/lib/Sema/TreeTransform.h", 5905, __extension__ __PRETTY_FUNCTION__
))
             "Parameter pack no longer a parameter pack after "(static_cast <bool> (NewParm->isParameterPack() &&
 "Parameter pack no longer a parameter pack after " "transformation."
) ? void (0) : __assert_fail ("NewParm->isParameterPack() && \"Parameter pack no longer a parameter pack after \" \"transformation.\""
, "clang/lib/Sema/TreeTransform.h", 5905, __extension__ __PRETTY_FUNCTION__
))
             "transformation.")(static_cast <bool> (NewParm->isParameterPack() &&
 "Parameter pack no longer a parameter pack after " "transformation."
) ? void (0) : __assert_fail ("NewParm->isParameterPack() && \"Parameter pack no longer a parameter pack after \" \"transformation.\""
, "clang/lib/Sema/TreeTransform.h", 5905, __extension__ __PRETTY_FUNCTION__
));
    } else {
      NewParm = getDerived().TransformFunctionTypeParam(
          OldParm, indexAdjustment, std::nullopt,
          /*ExpectParameterPack=*/false);
    }

    if (!NewParm)
      return true;

    if (ParamInfos)
      PInfos.set(OutParamTypes.size(), ParamInfos[i]);
    OutParamTypes.push_back(NewParm->getType());
    if (PVars)
      PVars->push_back(NewParm);
    continue;
  }

  // Deal with the possibility that we don't have a parameter
  // declaration for this parameter.
  assert(ParamTypes)(static_cast <bool> (ParamTypes) ? void (0) : __assert_fail
 ("ParamTypes", "clang/lib/Sema/TreeTransform.h", 5925, __extension__
 __PRETTY_FUNCTION__));
  QualType OldType = ParamTypes[i];
  bool IsPackExpansion = false;
  std::optional<unsigned> NumExpansions;
  QualType NewType;
  if (const PackExpansionType *Expansion
                                     = dyn_cast<PackExpansionType>(OldType)) {
    // We have a function parameter pack that may need to be expanded.
    QualType Pattern = Expansion->getPattern();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);

    // Determine whether we should expand the parameter packs.
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    if (getDerived().TryExpandParameterPacks(Loc, SourceRange(),
                                             Unexpanded,
                                             ShouldExpand,
                                             RetainExpansion,
                                             NumExpansions)) {
      return true;
    }

    if (ShouldExpand) {
      // Expand the function parameter pack into multiple, separate
      // parameters.
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        QualType NewType = getDerived().TransformType(Pattern);
        if (NewType.isNull())
          return true;

        if (NewType->containsUnexpandedParameterPack()) {
          NewType = getSema().getASTContext().getPackExpansionType(
              NewType, std::nullopt);

          if (NewType.isNull())
            return true;
        }

        if (ParamInfos)
          PInfos.set(OutParamTypes.size(), ParamInfos[i]);
        OutParamTypes.push_back(NewType);
        if (PVars)
          PVars->push_back(nullptr);
      }

      // We're done with the pack expansion.
      continue;
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());
      QualType NewType = getDerived().TransformType(Pattern);
      if (NewType.isNull())
        return true;

      if (ParamInfos)
        PInfos.set(OutParamTypes.size(), ParamInfos[i]);
      OutParamTypes.push_back(NewType);
      if (PVars)
        PVars->push_back(nullptr);
    }

    // We'll substitute the parameter now without expanding the pack
    // expansion.
    OldType = Expansion->getPattern();
    IsPackExpansion = true;
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
    NewType = getDerived().TransformType(OldType);
  } else {
    NewType = getDerived().TransformType(OldType);
  }

  if (NewType.isNull())
    return true;

  if (IsPackExpansion)
    NewType = getSema().Context.getPackExpansionType(NewType,
                                                     NumExpansions);

  if (ParamInfos)
    PInfos.set(OutParamTypes.size(), ParamInfos[i]);
  OutParamTypes.push_back(NewType);
  if (PVars)
    PVars->push_back(nullptr);
}

6015#ifndef NDEBUG
if (PVars) {
  for (unsigned i = 0, e = PVars->size(); i != e; ++i)
    if (ParmVarDecl *parm = (*PVars)[i])
      assert(parm->getFunctionScopeIndex() == i)(static_cast <bool> (parm->getFunctionScopeIndex() ==
 i) ? void (0) : __assert_fail ("parm->getFunctionScopeIndex() == i"
, "clang/lib/Sema/TreeTransform.h", 6019, __extension__ __PRETTY_FUNCTION__
));
}
6021#endif

return false;
6024}

6026template<typename Derived>
6027QualType
6028TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
                                                 FunctionProtoTypeLoc TL) {
SmallVector<QualType, 4> ExceptionStorage;
TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
return getDerived().TransformFunctionProtoType(
    TLB, TL, nullptr, Qualifiers(),
    [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
      return This->getDerived().TransformExceptionSpec(
          TL.getBeginLoc(), ESI, ExceptionStorage, Changed);
    });
6038}

6040template<typename Derived> template<typename Fn>
6041QualType TreeTransform<Derived>::TransformFunctionProtoType(
  TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
  Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {

// Transform the parameters and return type.
//
// We are required to instantiate the params and return type in source order.
// When the function has a trailing return type, we instantiate the
// parameters before the return type,  since the return type can then refer
// to the parameters themselves (via decltype, sizeof, etc.).
//
SmallVector<QualType, 4> ParamTypes;
SmallVector<ParmVarDecl*, 4> ParamDecls;
Sema::ExtParameterInfoBuilder ExtParamInfos;
const FunctionProtoType *T = TL.getTypePtr();

QualType ResultType;

if (T->hasTrailingReturn()) {
  if (getDerived().TransformFunctionTypeParams(
          TL.getBeginLoc(), TL.getParams(),
          TL.getTypePtr()->param_type_begin(),
          T->getExtParameterInfosOrNull(),
          ParamTypes, &ParamDecls, ExtParamInfos))
    return QualType();

  {
    // C++11 [expr.prim.general]p3:
    //   If a declaration declares a member function or member function
    //   template of a class X, the expression this is a prvalue of type
    //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
    //   and the end of the function-definition, member-declarator, or
    //   declarator.
    Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals);

    ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
    if (ResultType.isNull())
      return QualType();
  }
}
else {
  ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
  if (ResultType.isNull())
    return QualType();

  if (getDerived().TransformFunctionTypeParams(
          TL.getBeginLoc(), TL.getParams(),
          TL.getTypePtr()->param_type_begin(),
          T->getExtParameterInfosOrNull(),
          ParamTypes, &ParamDecls, ExtParamInfos))
    return QualType();
}

FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();

bool EPIChanged = false;
if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
  return QualType();

// Handle extended parameter information.
if (auto NewExtParamInfos =
      ExtParamInfos.getPointerOrNull(ParamTypes.size())) {
  if (!EPI.ExtParameterInfos ||
      llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) !=
          llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) {
    EPIChanged = true;
  }
  EPI.ExtParameterInfos = NewExtParamInfos;
} else if (EPI.ExtParameterInfos) {
  EPIChanged = true;
  EPI.ExtParameterInfos = nullptr;
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
    T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) {
  Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, 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(TL.getExceptionSpecRange());
NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i)
  NewTL.setParam(i, ParamDecls[i]);

return Result;
6132}

6134template<typename Derived>
6135bool TreeTransform<Derived>::TransformExceptionSpec(
  SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
  SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated)(static_cast <bool> (ESI.Type != EST_Uninstantiated &&
 ESI.Type != EST_Unevaluated) ? void (0) : __assert_fail ("ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated"
, "clang/lib/Sema/TreeTransform.h", 6138, __extension__ __PRETTY_FUNCTION__
));

// Instantiate a dynamic noexcept expression, if any.
if (isComputedNoexcept(ESI.Type)) {
  EnterExpressionEvaluationContext Unevaluated(
      getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
  if (NoexceptExpr.isInvalid())
    return true;

  ExceptionSpecificationType EST = ESI.Type;
  NoexceptExpr =
      getSema().ActOnNoexceptSpec(NoexceptExpr.get(), EST);
  if (NoexceptExpr.isInvalid())
    return true;

  if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type)
    Changed = true;
  ESI.NoexceptExpr = NoexceptExpr.get();
  ESI.Type = EST;
}

if (ESI.Type != EST_Dynamic)
  return false;

// Instantiate a dynamic exception specification's type.
for (QualType T : ESI.Exceptions) {
  if (const PackExpansionType *PackExpansion =
          T->getAs<PackExpansionType>()) {
    Changed = true;

    // We have a pack expansion. Instantiate it.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
                                            Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 6173, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can and
    // should
    // be expanded.
    bool Expand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
    // FIXME: Track the location of the ellipsis (and track source location
    // information for the types in the exception specification in general).
    if (getDerived().TryExpandParameterPacks(
            Loc, SourceRange(), Unexpanded, Expand,
            RetainExpansion, NumExpansions))
      return true;

    if (!Expand) {
      // We can't expand this pack expansion into separate arguments yet;
      // just substitute into the pattern and create a new pack expansion
      // type.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      QualType U = getDerived().TransformType(PackExpansion->getPattern());
      if (U.isNull())
        return true;

      U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
      Exceptions.push_back(U);
      continue;
    }

    // Substitute into the pack expansion pattern for each slice of the
    // pack.
    for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

      QualType U = getDerived().TransformType(PackExpansion->getPattern());
      if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
        return true;

      Exceptions.push_back(U);
    }
  } else {
    QualType U = getDerived().TransformType(T);
    if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
      return true;
    if (T != U)
      Changed = true;

    Exceptions.push_back(U);
  }
}

ESI.Exceptions = Exceptions;
if (ESI.Exceptions.empty())
  ESI.Type = EST_DynamicNone;
return false;
6228}

6230template<typename Derived>
6231QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
                                               TypeLocBuilder &TLB,
                                               FunctionNoProtoTypeLoc TL) {
const FunctionNoProtoType *T = TL.getTypePtr();
QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
if (ResultType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
  Result = getDerived().RebuildFunctionNoProtoType(ResultType);

FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());

return Result;
6250}

6252template <typename Derived>
6253QualType TreeTransform<Derived>::TransformUnresolvedUsingType(
  TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {
const UnresolvedUsingType *T = TL.getTypePtr();
Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
if (!D)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
  Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(), D);
  if (Result.isNull())
    return QualType();
}

// We might get an arbitrary type spec type back.  We should at
// least always get a type spec type, though.
TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6273}

6275template <typename Derived>
6276QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,
                                                  UsingTypeLoc TL) {
const UsingType *T = TL.getTypePtr();

auto *Found = cast_or_null<UsingShadowDecl>(getDerived().TransformDecl(
    TL.getLocalSourceRange().getBegin(), T->getFoundDecl()));
if (!Found)
  return QualType();

QualType Underlying = getDerived().TransformType(T->desugar());
if (Underlying.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || Found != T->getFoundDecl() ||
    Underlying != T->getUnderlyingType()) {
  Result = getDerived().RebuildUsingType(Found, Underlying);
  if (Result.isNull())
    return QualType();
}

TLB.pushTypeSpec(Result).setNameLoc(TL.getNameLoc());
return Result;
6299}

6301template<typename Derived>
6302QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
                                                    TypedefTypeLoc TL) {
const TypedefType *T = TL.getTypePtr();
TypedefNameDecl *Typedef
  = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                             T->getDecl()));
if (!Typedef)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Typedef != T->getDecl()) {
  Result = getDerived().RebuildTypedefType(Typedef);
  if (Result.isNull())
    return QualType();
}

TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6323}

6325template<typename Derived>
6326QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
                                                    TypeOfExprTypeLoc TL) {
// typeof expressions are not potentially evaluated contexts
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
if (E.isInvalid())
  return QualType();

E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
if (E.isInvalid())
  return QualType();

QualType Result = TL.getType();
TypeOfKind Kind = Result->getAs<TypeOfExprType>()->getKind();
if (getDerived().AlwaysRebuild() || E.get() != TL.getUnderlyingExpr()) {
  Result =
      getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc(), Kind);
  if (Result.isNull())
    return QualType();
}

TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
NewTL.setTypeofLoc(TL.getTypeofLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());

return Result;
6356}

6358template<typename Derived>
6359QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
                                                   TypeOfTypeLoc TL) {
TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo();
TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
17
←
Calling 'TreeTransform::TransformType'→
21
←
Returning from 'TreeTransform::TransformType'→
if (!New_Under_TI)
22
←
Assuming 'New_Under_TI' is non-null→
23
←
Taking false branch→
  return QualType();

QualType Result = TL.getType();
TypeOfKind Kind = Result->getAs<TypeOfType>()->getKind();
24
←
Assuming the object is not a 'const class clang::TypeOfType *'→
25
←
Called C++ object pointer is null
if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
  Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);
  if (Result.isNull())
    return QualType();
}

TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
NewTL.setTypeofLoc(TL.getTypeofLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
NewTL.setUnmodifiedTInfo(New_Under_TI);

return Result;
6381}

6383template<typename Derived>
6384QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
                                                     DecltypeTypeLoc TL) {
const DecltypeType *T = TL.getTypePtr();

// decltype expressions are not potentially evaluated contexts
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, nullptr,
    Sema::ExpressionEvaluationContextRecord::EK_Decltype);

ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
if (E.isInvalid())
  return QualType();

E = getSema().ActOnDecltypeExpression(E.get());
if (E.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    E.get() != T->getUnderlyingExpr()) {
  Result = getDerived().RebuildDecltypeType(E.get(), TL.getDecltypeLoc());
  if (Result.isNull())
    return QualType();
}
else E.get();

DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
NewTL.setDecltypeLoc(TL.getDecltypeLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
return Result;
6414}

6416template<typename Derived>
6417QualType TreeTransform<Derived>::TransformUnaryTransformType(
                                                          TypeLocBuilder &TLB,
                                                   UnaryTransformTypeLoc TL) {
QualType Result = TL.getType();
if (Result->isDependentType()) {
  const UnaryTransformType *T = TL.getTypePtr();
  QualType NewBase =
    getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
  Result = getDerived().RebuildUnaryTransformType(NewBase,
                                                  T->getUTTKind(),
                                                  TL.getKWLoc());
  if (Result.isNull())
    return QualType();
}

UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());
NewTL.setParensRange(TL.getParensRange());
NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
return Result;
6437}

6439template<typename Derived>
6440QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
  TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
const DeducedTemplateSpecializationType *T = TL.getTypePtr();

CXXScopeSpec SS;
TemplateName TemplateName = getDerived().TransformTemplateName(
    SS, T->getTemplateName(), TL.getTemplateNameLoc());
if (TemplateName.isNull())
  return QualType();

QualType OldDeduced = T->getDeducedType();
QualType NewDeduced;
if (!OldDeduced.isNull()) {
  NewDeduced = getDerived().TransformType(OldDeduced);
  if (NewDeduced.isNull())
    return QualType();
}

QualType Result = getDerived().RebuildDeducedTemplateSpecializationType(
    TemplateName, NewDeduced);
if (Result.isNull())
  return QualType();

DeducedTemplateSpecializationTypeLoc NewTL =
    TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());

return Result;
6468}

6470template<typename Derived>
6471QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
                                                   RecordTypeLoc TL) {
const RecordType *T = TL.getTypePtr();
RecordDecl *Record
  = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                        T->getDecl()));
if (!Record)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Record != T->getDecl()) {
  Result = getDerived().RebuildRecordType(Record);
  if (Result.isNull())
    return QualType();
}

RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6492}

6494template<typename Derived>
6495QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
                                                 EnumTypeLoc TL) {
const EnumType *T = TL.getTypePtr();
EnumDecl *Enum
  = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                      T->getDecl()));
if (!Enum)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Enum != T->getDecl()) {
  Result = getDerived().RebuildEnumType(Enum);
  if (Result.isNull())
    return QualType();
}

EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6516}

6518template<typename Derived>
6519QualType TreeTransform<Derived>::TransformInjectedClassNameType(
                                       TypeLocBuilder &TLB,
                                       InjectedClassNameTypeLoc TL) {
Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
                                     TL.getTypePtr()->getDecl());
if (!D) return QualType();

QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
return T;
6529}

6531template<typename Derived>
6532QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
                                              TypeLocBuilder &TLB,
                                              TemplateTypeParmTypeLoc TL) {
return getDerived().TransformTemplateTypeParmType(
    TLB, TL,
    /*SuppressObjCLifetime=*/false);
6538}

6540template <typename Derived>
6541QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
  TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) {
return TransformTypeSpecType(TLB, TL);
6544}

6546template<typename Derived>
6547QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
                                       TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmTypeLoc TL) {
const SubstTemplateTypeParmType *T = TL.getTypePtr();

Decl *NewReplaced =
    getDerived().TransformDecl(TL.getNameLoc(), T->getAssociatedDecl());

// Substitute into the replacement type, which itself might involve something
// that needs to be transformed. This only tends to occur with default
// template arguments of template template parameters.
TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
QualType Replacement = getDerived().TransformType(T->getReplacementType());
if (Replacement.isNull())
  return QualType();

QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
    Replacement, NewReplaced, T->getIndex(), T->getPackIndex());

// Propagate type-source information.
SubstTemplateTypeParmTypeLoc NewTL
  = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;

6572}

6574template<typename Derived>
6575QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
                                        TypeLocBuilder &TLB,
                                        SubstTemplateTypeParmPackTypeLoc TL) {
return getDerived().TransformSubstTemplateTypeParmPackType(
    TLB, TL, /*SuppressObjCLifetime=*/false);
6580}

6582template <typename Derived>
6583QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
  TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) {
return TransformTypeSpecType(TLB, TL);
6586}

6588template<typename Derived>
6589QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                      TypeLocBuilder &TLB,
                                         TemplateSpecializationTypeLoc TL) {
const TemplateSpecializationType *T = TL.getTypePtr();

// The nested-name-specifier never matters in a TemplateSpecializationType,
// because we can't have a dependent nested-name-specifier anyway.
CXXScopeSpec SS;
TemplateName Template
  = getDerived().TransformTemplateName(SS, T->getTemplateName(),
                                       TL.getTemplateNameLoc());
if (Template.isNull())
  return QualType();

return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
6604}

6606template<typename Derived>
6607QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
                                                   AtomicTypeLoc TL) {
QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
if (ValueType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ValueType != TL.getValueLoc().getType()) {
  Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
  if (Result.isNull())
    return QualType();
}

AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());

return Result;
6627}

6629template <typename Derived>
6630QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
                                                 PipeTypeLoc TL) {
QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
if (ValueType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
  const PipeType *PT = Result->castAs<PipeType>();
  bool isReadPipe = PT->isReadOnly();
  Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
  if (Result.isNull())
    return QualType();
}

PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());

return Result;
6649}

6651template <typename Derived>
6652QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,
                                                   BitIntTypeLoc TL) {
const BitIntType *EIT = TL.getTypePtr();
QualType Result = TL.getType();

if (getDerived().AlwaysRebuild()) {
  Result = getDerived().RebuildBitIntType(EIT->isUnsigned(),
                                          EIT->getNumBits(), TL.getNameLoc());
  if (Result.isNull())
    return QualType();
}

BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
6667}

6669template <typename Derived>
6670QualType TreeTransform<Derived>::TransformDependentBitIntType(
  TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {
const DependentBitIntType *EIT = TL.getTypePtr();

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
BitsExpr = SemaRef.ActOnConstantExpression(BitsExpr);

if (BitsExpr.isInvalid())
  return QualType();

QualType Result = TL.getType();

if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
  Result = getDerived().RebuildDependentBitIntType(
      EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());

  if (Result.isNull())
    return QualType();
}

if (isa<DependentBitIntType>(Result)) {
  DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}
return Result;
6700}

/// Simple iterator that traverses the template arguments in a
/// container that provides a \c getArgLoc() member function.
///
/// This iterator is intended to be used with the iterator form of
/// \c TreeTransform<Derived>::TransformTemplateArguments().
template<typename ArgLocContainer>
class TemplateArgumentLocContainerIterator {
  ArgLocContainer *Container;
  unsigned Index;

public:
  typedef TemplateArgumentLoc value_type;
  typedef TemplateArgumentLoc reference;
  typedef int difference_type;
  typedef std::input_iterator_tag iterator_category;

  class pointer {
    TemplateArgumentLoc Arg;

  public:
    explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }

    const TemplateArgumentLoc *operator->() const {
      return &Arg;
    }
  };


  TemplateArgumentLocContainerIterator() {}

  TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
                               unsigned Index)
    : Container(&Container), Index(Index) { }

  TemplateArgumentLocContainerIterator &operator++() {
    ++Index;
    return *this;
  }

  TemplateArgumentLocContainerIterator operator++(int) {
    TemplateArgumentLocContainerIterator Old(*this);
    ++(*this);
    return Old;
  }

  TemplateArgumentLoc operator*() const {
    return Container->getArgLoc(Index);
  }

  pointer operator->() const {
    return pointer(Container->getArgLoc(Index));
  }

  friend bool operator==(const TemplateArgumentLocContainerIterator &X,
                         const TemplateArgumentLocContainerIterator &Y) {
    return X.Container == Y.Container && X.Index == Y.Index;
  }

  friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
                         const TemplateArgumentLocContainerIterator &Y) {
    return !(X == Y);
  }
};

6766template<typename Derived>
6767QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
                                                 AutoTypeLoc TL) {
const AutoType *T = TL.getTypePtr();
QualType OldDeduced = T->getDeducedType();
QualType NewDeduced;
if (!OldDeduced.isNull()) {
  NewDeduced = getDerived().TransformType(OldDeduced);
  if (NewDeduced.isNull())
    return QualType();
}

ConceptDecl *NewCD = nullptr;
TemplateArgumentListInfo NewTemplateArgs;
NestedNameSpecifierLoc NewNestedNameSpec;
if (T->isConstrained()) {
  NewCD = cast_or_null<ConceptDecl>(getDerived().TransformDecl(
      TL.getConceptNameLoc(), T->getTypeConstraintConcept()));

  NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
  NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
  typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
  if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                              ArgIterator(TL,
                                                          TL.getNumArgs()),
                                              NewTemplateArgs))
    return QualType();

  if (TL.getNestedNameSpecifierLoc()) {
    NewNestedNameSpec
      = getDerived().TransformNestedNameSpecifierLoc(
          TL.getNestedNameSpecifierLoc());
    if (!NewNestedNameSpec)
      return QualType();
  }
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
    T->isDependentType() || T->isConstrained()) {
  // FIXME: Maybe don't rebuild if all template arguments are the same.
  llvm::SmallVector<TemplateArgument, 4> NewArgList;
  NewArgList.reserve(NewTemplateArgs.size());
  for (const auto &ArgLoc : NewTemplateArgs.arguments())
    NewArgList.push_back(ArgLoc.getArgument());
  Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
                                        NewArgList);
  if (Result.isNull())
    return QualType();
}

AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec);
NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
NewTL.setConceptNameLoc(TL.getConceptNameLoc());
NewTL.setFoundDecl(TL.getFoundDecl());
NewTL.setLAngleLoc(TL.getLAngleLoc());
NewTL.setRAngleLoc(TL.getRAngleLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
for (unsigned I = 0; I < NewTL.getNumArgs(); ++I)
  NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo());

return Result;
6830}

6832template <typename Derived>
6833QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                      TypeLocBuilder &TLB,
                                         TemplateSpecializationTypeLoc TL,
                                                    TemplateName Template) {
TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
  ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

// FIXME: maybe don't rebuild if all the template arguments are the same.

QualType Result =
  getDerived().RebuildTemplateSpecializationType(Template,
                                                 TL.getTemplateNameLoc(),
                                                 NewTemplateArgs);

if (!Result.isNull()) {
  // Specializations of template template parameters are represented as
  // TemplateSpecializationTypes, and substitution of type alias templates
  // within a dependent context can transform them into
  // DependentTemplateSpecializationTypes.
  if (isa<DependentTemplateSpecializationType>(Result)) {
    DependentTemplateSpecializationTypeLoc NewTL
      = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
    NewTL.setElaboratedKeywordLoc(SourceLocation());
    NewTL.setQualifierLoc(NestedNameSpecifierLoc());
    NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
    NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
    NewTL.setLAngleLoc(TL.getLAngleLoc());
    NewTL.setRAngleLoc(TL.getRAngleLoc());
    for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
      NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
    return Result;
  }

  TemplateSpecializationTypeLoc NewTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
}

return Result;
6884}

6886template <typename Derived>
6887QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
                                   TypeLocBuilder &TLB,
                                   DependentTemplateSpecializationTypeLoc TL,
                                   TemplateName Template,
                                   CXXScopeSpec &SS) {
TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
typedef TemplateArgumentLocContainerIterator<
          DependentTemplateSpecializationTypeLoc> ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

// FIXME: maybe don't rebuild if all the template arguments are the same.

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType Result = getSema().Context.getDependentTemplateSpecializationType(
      TL.getTypePtr()->getKeyword(), DTN->getQualifier(),
      DTN->getIdentifier(), NewTemplateArgs.arguments());

  DependentTemplateSpecializationTypeLoc NewTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
  return Result;
}

QualType Result
  = getDerived().RebuildTemplateSpecializationType(Template,
                                                   TL.getTemplateNameLoc(),
                                                   NewTemplateArgs);

if (!Result.isNull()) {
  /// FIXME: Wrap this in an elaborated-type-specifier?
  TemplateSpecializationTypeLoc NewTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
}

return Result;
6940}

6942template<typename Derived>
6943QualType
6944TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
                                              ElaboratedTypeLoc TL) {
const ElaboratedType *T = TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc;
// NOTE: the qualifier in an ElaboratedType is optional.
if (TL.getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
  if (!QualifierLoc)
    return QualType();
}

QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
if (NamedT.isNull())
  return QualType();

// 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.
if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) {
  if (const TemplateSpecializationType *TST =
        NamedT->getAs<TemplateSpecializationType>()) {
    TemplateName Template = TST->getTemplateName();
    if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
            Template.getAsTemplateDecl())) {
      SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(),
                   diag::err_tag_reference_non_tag)
          << TAT << Sema::NTK_TypeAliasTemplate
          << ElaboratedType::getTagTypeKindForKeyword(T->getKeyword());
      SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
    }
  }
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    QualifierLoc != TL.getQualifierLoc() ||
    NamedT != T->getNamedType()) {
  Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(),
                                              T->getKeyword(),
                                              QualifierLoc, NamedT);
  if (Result.isNull())
    return QualType();
}

ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
NewTL.setQualifierLoc(QualifierLoc);
return Result;
6995}

6997template<typename Derived>
6998QualType TreeTransform<Derived>::TransformAttributedType(
                                              TypeLocBuilder &TLB,
                                              AttributedTypeLoc TL) {
const AttributedType *oldType = TL.getTypePtr();
QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
if (modifiedType.isNull())
  return QualType();

// oldAttr can be null if we started with a QualType rather than a TypeLoc.
const Attr *oldAttr = TL.getAttr();
const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) : nullptr;
if (oldAttr && !newAttr)
  return QualType();

QualType result = TL.getType();

// FIXME: dependent operand expressions?
if (getDerived().AlwaysRebuild() ||
    modifiedType != oldType->getModifiedType()) {
  // TODO: this is really lame; we should really be rebuilding the
  // equivalent type from first principles.
  QualType equivalentType
    = getDerived().TransformType(oldType->getEquivalentType());
  if (equivalentType.isNull())
    return QualType();

  // Check whether we can add nullability; it is only represented as
  // type sugar, and therefore cannot be diagnosed in any other way.
  if (auto nullability = oldType->getImmediateNullability()) {
    if (!modifiedType->canHaveNullability()) {
      SemaRef.Diag((TL.getAttr() ? TL.getAttr()->getLocation()
                                 : TL.getModifiedLoc().getBeginLoc()),
                   diag::err_nullability_nonpointer)
          << DiagNullabilityKind(*nullability, false) << modifiedType;
      return QualType();
    }
  }

  result = SemaRef.Context.getAttributedType(TL.getAttrKind(),
                                             modifiedType,
                                             equivalentType);
}

AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
newTL.setAttr(newAttr);
return result;
7044}

7046template <typename Derived>
7047QualType TreeTransform<Derived>::TransformBTFTagAttributedType(
  TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {
// The BTFTagAttributedType is available for C only.
llvm_unreachable("Unexpected TreeTransform for BTFTagAttributedType")::llvm::llvm_unreachable_internal("Unexpected TreeTransform for BTFTagAttributedType"
, "clang/lib/Sema/TreeTransform.h", 7050);
7051}

7053template<typename Derived>
7054QualType
7055TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
                                         ParenTypeLoc TL) {
QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
if (Inner.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Inner != TL.getInnerLoc().getType()) {
  Result = getDerived().RebuildParenType(Inner);
  if (Result.isNull())
    return QualType();
}

ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
return Result;
7073}

7075template <typename Derived>
7076QualType
7077TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
                                                  MacroQualifiedTypeLoc TL) {
QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
if (Inner.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
  Result =
      getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
  if (Result.isNull())
    return QualType();
}

MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result);
NewTL.setExpansionLoc(TL.getExpansionLoc());
return Result;
7094}

7096template<typename Derived>
7097QualType TreeTransform<Derived>::TransformDependentNameType(
  TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
return TransformDependentNameType(TLB, TL, false);
7100}

7102template<typename Derived>
7103QualType TreeTransform<Derived>::TransformDependentNameType(
  TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext) {
const DependentNameType *T = TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
if (!QualifierLoc)
  return QualType();

QualType Result
  = getDerived().RebuildDependentNameType(T->getKeyword(),
                                          TL.getElaboratedKeywordLoc(),
                                          QualifierLoc,
                                          T->getIdentifier(),
                                          TL.getNameLoc(),
                                          DeducedTSTContext);
if (Result.isNull())
  return QualType();

if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
  QualType NamedT = ElabT->getNamedType();
  TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());

  ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
} else {
  DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
  NewTL.setNameLoc(TL.getNameLoc());
}
return Result;
7136}

7138template<typename Derived>
7139QualType TreeTransform<Derived>::
        TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                               DependentTemplateSpecializationTypeLoc TL) {
NestedNameSpecifierLoc QualifierLoc;
if (TL.getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
  if (!QualifierLoc)
    return QualType();
}

return getDerived()
         .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
7152}

7154template<typename Derived>
7155QualType TreeTransform<Derived>::
7156TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                                 DependentTemplateSpecializationTypeLoc TL,
                                     NestedNameSpecifierLoc QualifierLoc) {
const DependentTemplateSpecializationType *T = TL.getTypePtr();

TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());

typedef TemplateArgumentLocContainerIterator<
DependentTemplateSpecializationTypeLoc> ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
    T->getKeyword(), QualifierLoc, TL.getTemplateKeywordLoc(),
    T->getIdentifier(), TL.getTemplateNameLoc(), NewTemplateArgs,
    /*AllowInjectedClassName*/ false);
if (Result.isNull())
  return QualType();

if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
  QualType NamedT = ElabT->getNamedType();

  // Copy information relevant to the template specialization.
  TemplateSpecializationTypeLoc NamedTL
    = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
  NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NamedTL.setLAngleLoc(TL.getLAngleLoc());
  NamedTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());

  // Copy information relevant to the elaborated type.
  ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
} else if (isa<DependentTemplateSpecializationType>(Result)) {
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
  SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  SpecTL.setQualifierLoc(QualifierLoc);
  SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  SpecTL.setLAngleLoc(TL.getLAngleLoc());
  SpecTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
} else {
  TemplateSpecializationTypeLoc SpecTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  SpecTL.setLAngleLoc(TL.getLAngleLoc());
  SpecTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
}
return Result;
7218}

7220template<typename Derived>
7221QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
                                                    PackExpansionTypeLoc TL) {
QualType Pattern
  = getDerived().TransformType(TLB, TL.getPatternLoc());
if (Pattern.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Pattern != TL.getPatternLoc().getType()) {
  Result = getDerived().RebuildPackExpansionType(Pattern,
                                         TL.getPatternLoc().getSourceRange(),
                                                 TL.getEllipsisLoc(),
                                         TL.getTypePtr()->getNumExpansions());
  if (Result.isNull())
    return QualType();
}

PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
NewT.setEllipsisLoc(TL.getEllipsisLoc());
return Result;
7242}

7244template<typename Derived>
7245QualType
7246TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
                                                 ObjCInterfaceTypeLoc TL) {
// ObjCInterfaceType is never dependent.
TLB.pushFullCopy(TL);
return TL.getType();
7251}

7253template<typename Derived>
7254QualType
7255TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
                                                 ObjCTypeParamTypeLoc TL) {
const ObjCTypeParamType *T = TL.getTypePtr();
ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
    getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
if (!OTP)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    OTP != T->getDecl()) {
  Result = getDerived().RebuildObjCTypeParamType(
      OTP, TL.getProtocolLAngleLoc(),
      llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
      TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
  if (Result.isNull())
    return QualType();
}

ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
if (TL.getNumProtocols()) {
  NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
  for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
    NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
  NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
}
return Result;
7282}

7284template<typename Derived>
7285QualType
7286TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
                                              ObjCObjectTypeLoc TL) {
// Transform base type.
QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
if (BaseType.isNull())
  return QualType();

bool AnyChanged = BaseType != TL.getBaseLoc().getType();

// Transform type arguments.
SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
  TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
  TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
  QualType TypeArg = TypeArgInfo->getType();
  if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
    AnyChanged = true;

    // We have a pack expansion. Instantiate it.
    const auto *PackExpansion = PackExpansionLoc.getType()
                                  ->castAs<PackExpansionType>();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
                                            Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 7310, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can
    // and should be expanded.
    TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
    bool Expand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
    if (getDerived().TryExpandParameterPacks(
          PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
          Unexpanded, Expand, RetainExpansion, NumExpansions))
      return QualType();

    if (!Expand) {
      // We can't expand this pack expansion into separate arguments yet;
      // just substitute into the pattern and create a new pack expansion
      // type.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

      TypeLocBuilder TypeArgBuilder;
      TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
      QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
                                                           PatternLoc);
      if (NewPatternType.isNull())
        return QualType();

      QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
                                    NewPatternType, NumExpansions);
      auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
      NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
      NewTypeArgInfos.push_back(
        TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
      continue;
    }

    // Substitute into the pack expansion pattern for each slice of the
    // pack.
    for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

      TypeLocBuilder TypeArgBuilder;
      TypeArgBuilder.reserve(PatternLoc.getFullDataSize());

      QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
                                                       PatternLoc);
      if (NewTypeArg.isNull())
        return QualType();

      NewTypeArgInfos.push_back(
        TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
    }

    continue;
  }

  TypeLocBuilder TypeArgBuilder;
  TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
  QualType NewTypeArg =
      getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
  if (NewTypeArg.isNull())
    return QualType();

  // If nothing changed, just keep the old TypeSourceInfo.
  if (NewTypeArg == TypeArg) {
    NewTypeArgInfos.push_back(TypeArgInfo);
    continue;
  }

  NewTypeArgInfos.push_back(
    TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
  AnyChanged = true;
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || AnyChanged) {
  // Rebuild the type.
  Result = getDerived().RebuildObjCObjectType(
      BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
      TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
      llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
      TL.getProtocolLocs(), TL.getProtocolRAngleLoc());

  if (Result.isNull())
    return QualType();
}

ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
NewT.setHasBaseTypeAsWritten(true);
NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
  NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
  NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
return Result;
7407}

7409template<typename Derived>
7410QualType
7411TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
                                             ObjCObjectPointerTypeLoc TL) {
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
                                                     TL.getStarLoc());
  if (Result.isNull())
    return QualType();
}

ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
NewT.setStarLoc(TL.getStarLoc());
return Result;
7429}

7431//===----------------------------------------------------------------------===//
7432// Statement transformation
7433//===----------------------------------------------------------------------===//
7434template<typename Derived>
7435StmtResult
7436TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
return S;
7438}

7440template<typename Derived>
7441StmtResult
7442TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
return getDerived().TransformCompoundStmt(S, false);
7444}

7446template<typename Derived>
7447StmtResult
7448TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
                                            bool IsStmtExpr) {
Sema::CompoundScopeRAII CompoundScope(getSema());

const Stmt *ExprResult = S->getStmtExprResult();
bool SubStmtInvalid = false;
bool SubStmtChanged = false;
SmallVector<Stmt*, 8> Statements;
for (auto *B : S->body()) {
  StmtResult Result = getDerived().TransformStmt(
      B, IsStmtExpr && B == ExprResult ? SDK_StmtExprResult : SDK_Discarded);

  if (Result.isInvalid()) {
    // Immediately fail if this was a DeclStmt, since it's very
    // likely that this will cause problems for future statements.
    if (isa<DeclStmt>(B))
      return StmtError();

    // Otherwise, just keep processing substatements and fail later.
    SubStmtInvalid = true;
    continue;
  }

  SubStmtChanged = SubStmtChanged || Result.get() != B;
  Statements.push_back(Result.getAs<Stmt>());
}

if (SubStmtInvalid)
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    !SubStmtChanged)
  return S;

return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
                                        Statements,
                                        S->getRBracLoc(),
                                        IsStmtExpr);
7486}

7488template<typename Derived>
7489StmtResult
7490TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
ExprResult LHS, RHS;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  // Transform the left-hand case value.
  LHS = getDerived().TransformExpr(S->getLHS());
  LHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), LHS);
  if (LHS.isInvalid())
    return StmtError();

  // Transform the right-hand case value (for the GNU case-range extension).
  RHS = getDerived().TransformExpr(S->getRHS());
  RHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), RHS);
  if (RHS.isInvalid())
    return StmtError();
}

// Build the case statement.
// Case statements are always rebuilt so that they will attached to their
// transformed switch statement.
StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
                                                     LHS.get(),
                                                     S->getEllipsisLoc(),
                                                     RHS.get(),
                                                     S->getColonLoc());
if (Case.isInvalid())
  return StmtError();

// Transform the statement following the case
StmtResult SubStmt =
    getDerived().TransformStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// Attach the body to the case statement
return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
7528}

7530template <typename Derived>
7531StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
// Transform the statement following the default case
StmtResult SubStmt =
    getDerived().TransformStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// Default statements are always rebuilt
return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
                                       SubStmt.get());
7541}

7543template<typename Derived>
7544StmtResult
7545TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
if (SubStmt.isInvalid())
  return StmtError();

Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
                                      S->getDecl());
if (!LD)
  return StmtError();

// If we're transforming "in-place" (we're not creating new local
// declarations), assume we're replacing the old label statement
// and clear out the reference to it.
if (LD == S->getDecl())
  S->getDecl()->setStmt(nullptr);

// FIXME: Pass the real colon location in.
return getDerived().RebuildLabelStmt(S->getIdentLoc(),
                                     cast<LabelDecl>(LD), SourceLocation(),
                                     SubStmt.get());
7565}

7567template <typename Derived>
7568const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
if (!R)
  return R;

switch (R->getKind()) {
7573// Transform attributes by calling TransformXXXAttr.
7574#define ATTR(X)                                                                \
case attr::X:                                                                \
  return getDerived().Transform##X##Attr(cast<X##Attr>(R));
7577#include "clang/Basic/AttrList.inc"
}
return R;
7580}

7582template <typename Derived>
7583const Attr *TreeTransform<Derived>::TransformStmtAttr(const Stmt *OrigS,
                                                    const Stmt *InstS,
                                                    const Attr *R) {
if (!R)
  return R;

switch (R->getKind()) {
7590// Transform attributes by calling TransformStmtXXXAttr.
7591#define ATTR(X)                                                                \
case attr::X:                                                                \
  return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R));
7594#include "clang/Basic/AttrList.inc"
}
return TransformAttr(R);
7597}

7599template <typename Derived>
7600StmtResult
7601TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S,
                                              StmtDiscardKind SDK) {
StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
if (SubStmt.isInvalid())
  return StmtError();

bool AttrsChanged = false;
SmallVector<const Attr *, 1> Attrs;

// Visit attributes and keep track if any are transformed.
for (const auto *I : S->getAttrs()) {
  const Attr *R =
      getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.get(), I);
  AttrsChanged |= (I != R);
  if (R)
    Attrs.push_back(R);
}

if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
  return S;

// If transforming the attributes failed for all of the attributes in the
// statement, don't make an AttributedStmt without attributes.
if (Attrs.empty())
  return SubStmt;

return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
                                          SubStmt.get());
7629}

7631template<typename Derived>
7632StmtResult
7633TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

Sema::ConditionResult Cond;
if (!S->isConsteval()) {
  // Transform the condition
  Cond = getDerived().TransformCondition(
      S->getIfLoc(), S->getConditionVariable(), S->getCond(),
      S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
                       : Sema::ConditionKind::Boolean);
  if (Cond.isInvalid())
    return StmtError();
}

// If this is a constexpr if, determine which arm we should instantiate.
std::optional<bool> ConstexprConditionValue;
if (S->isConstexpr())
  ConstexprConditionValue = Cond.getKnownValue();

// Transform the "then" branch.
StmtResult Then;
if (!ConstexprConditionValue || *ConstexprConditionValue) {
  Then = getDerived().TransformStmt(S->getThen());
  if (Then.isInvalid())
    return StmtError();
} else {
  Then = new (getSema().Context) NullStmt(S->getThen()->getBeginLoc());
}

// Transform the "else" branch.
StmtResult Else;
if (!ConstexprConditionValue || !*ConstexprConditionValue) {
  Else = getDerived().TransformStmt(S->getElse());
  if (Else.isInvalid())
    return StmtError();
}

if (!getDerived().AlwaysRebuild() &&
    Init.get() == S->getInit() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Then.get() == S->getThen() &&
    Else.get() == S->getElse())
  return S;

return getDerived().RebuildIfStmt(
    S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
    S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get());
7683}

7685template<typename Derived>
7686StmtResult
7687TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// Transform the condition.
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Switch);
if (Cond.isInvalid())
  return StmtError();

// Rebuild the switch statement.
StmtResult Switch =
    getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
                                        Init.get(), Cond, S->getRParenLoc());
if (Switch.isInvalid())
  return StmtError();

// Transform the body of the switch statement.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Complete the switch statement.
return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
                                          Body.get());
7715}

7717template<typename Derived>
7718StmtResult
7719TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Body.get() == S->getBody())
  return Owned(S);

return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
                                     Cond, S->getRParenLoc(), Body.get());
7739}

7741template<typename Derived>
7742StmtResult
7743TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Transform the condition
ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == S->getCond() &&
    Body.get() == S->getBody())
  return S;

return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
                                  /*FIXME:*/S->getWhileLoc(), Cond.get(),
                                  S->getRParenLoc());
7762}

7764template<typename Derived>
7765StmtResult
7766TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
if (getSema().getLangOpts().OpenMP)
  getSema().startOpenMPLoop();

// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// In OpenMP loop region loop control variable must be captured and be
// private. Perform analysis of first part (if any).
if (getSema().getLangOpts().OpenMP && Init.isUsable())
  getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());

// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getForLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// Transform the increment
ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
  return StmtError();

Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
if (S->getInc() && !FullInc.get())
  return StmtError();

// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Init.get() == S->getInit() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Inc.get() == S->getInc() &&
    Body.get() == S->getBody())
  return S;

return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
                                   Init.get(), Cond, FullInc,
                                   S->getRParenLoc(), Body.get());
7811}

7813template<typename Derived>
7814StmtResult
7815TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
                                      S->getLabel());
if (!LD)
  return StmtError();

// Goto statements must always be rebuilt, to resolve the label.
return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
                                    cast<LabelDecl>(LD));
7824}

7826template<typename Derived>
7827StmtResult
7828TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
ExprResult Target = getDerived().TransformExpr(S->getTarget());
if (Target.isInvalid())
  return StmtError();
Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());

if (!getDerived().AlwaysRebuild() &&
    Target.get() == S->getTarget())
  return S;

return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
                                            Target.get());
7840}

7842template<typename Derived>
7843StmtResult
7844TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
return S;
7846}

7848template<typename Derived>
7849StmtResult
7850TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
return S;
7852}

7854template<typename Derived>
7855StmtResult
7856TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return StmtError();

// FIXME: We always rebuild the return statement because there is no way
// to tell whether the return type of the function has changed.
return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
7865}

7867template<typename Derived>
7868StmtResult
7869TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
bool DeclChanged = false;
SmallVector<Decl *, 4> Decls;
for (auto *D : S->decls()) {
  Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
  if (!Transformed)
    return StmtError();

  if (Transformed != D)
    DeclChanged = true;

  Decls.push_back(Transformed);
}

if (!getDerived().AlwaysRebuild() && !DeclChanged)
  return S;

return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
7887}

7889template<typename Derived>
7890StmtResult
7891TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {

SmallVector<Expr*, 8> Constraints;
SmallVector<Expr*, 8> Exprs;
SmallVector<IdentifierInfo *, 4> Names;

ExprResult AsmString;
SmallVector<Expr*, 8> Clobbers;

bool ExprsChanged = false;

// Go through the outputs.
for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
  Names.push_back(S->getOutputIdentifier(I));

  // No need to transform the constraint literal.
  Constraints.push_back(S->getOutputConstraintLiteral(I));

  // Transform the output expr.
  Expr *OutputExpr = S->getOutputExpr(I);
  ExprResult Result = getDerived().TransformExpr(OutputExpr);
  if (Result.isInvalid())
    return StmtError();

  ExprsChanged |= Result.get() != OutputExpr;

  Exprs.push_back(Result.get());
}

// Go through the inputs.
for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
  Names.push_back(S->getInputIdentifier(I));

  // No need to transform the constraint literal.
  Constraints.push_back(S->getInputConstraintLiteral(I));

  // Transform the input expr.
  Expr *InputExpr = S->getInputExpr(I);
  ExprResult Result = getDerived().TransformExpr(InputExpr);
  if (Result.isInvalid())
    return StmtError();

  ExprsChanged |= Result.get() != InputExpr;

  Exprs.push_back(Result.get());
}

// Go through the Labels.
for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
  Names.push_back(S->getLabelIdentifier(I));

  ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I));
  if (Result.isInvalid())
    return StmtError();
  ExprsChanged |= Result.get() != S->getLabelExpr(I);
  Exprs.push_back(Result.get());
}
if (!getDerived().AlwaysRebuild() && !ExprsChanged)
  return S;

// Go through the clobbers.
for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
  Clobbers.push_back(S->getClobberStringLiteral(I));

// No need to transform the asm string literal.
AsmString = S->getAsmString();
return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
                                      S->isVolatile(), S->getNumOutputs(),
                                      S->getNumInputs(), Names.data(),
                                      Constraints, Exprs, AsmString.get(),
                                      Clobbers, S->getNumLabels(),
                                      S->getRParenLoc());
7963}

7965template<typename Derived>
7966StmtResult
7967TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks());

bool HadError = false, HadChange = false;

ArrayRef<Expr*> SrcExprs = S->getAllExprs();
SmallVector<Expr*, 8> TransformedExprs;
TransformedExprs.reserve(SrcExprs.size());
for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
  ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
  if (!Result.isUsable()) {
    HadError = true;
  } else {
    HadChange |= (Result.get() != SrcExprs[i]);
    TransformedExprs.push_back(Result.get());
  }
}

if (HadError) return StmtError();
if (!HadChange && !getDerived().AlwaysRebuild())
  return Owned(S);

return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
                                     AsmToks, S->getAsmString(),
                                     S->getNumOutputs(), S->getNumInputs(),
                                     S->getAllConstraints(), S->getClobbers(),
                                     TransformedExprs, S->getEndLoc());
7994}

7996// C++ Coroutines
7997template<typename Derived>
7998StmtResult
7999TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
auto *ScopeInfo = SemaRef.getCurFunction();
auto *FD = cast<FunctionDecl>(SemaRef.CurContext);
assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       ScopeInfo->NeedsCoroutineSuspends &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       ScopeInfo->CoroutineSuspends.first == nullptr &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       ScopeInfo->CoroutineSuspends.second == nullptr &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       "expected clean scope info")(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
));

// Set that we have (possibly-invalid) suspend points before we do anything
// that may fail.
ScopeInfo->setNeedsCoroutineSuspends(false);

// We re-build the coroutine promise object (and the coroutine parameters its
// type and constructor depend on) based on the types used in our current
// function. We must do so, and set it on the current FunctionScopeInfo,
// before attempting to transform the other parts of the coroutine body
// statement, such as the implicit suspend statements (because those
// statements reference the FunctionScopeInfo::CoroutinePromise).
if (!SemaRef.buildCoroutineParameterMoves(FD->getLocation()))
  return StmtError();
auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation());
if (!Promise)
  return StmtError();
getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
ScopeInfo->CoroutinePromise = Promise;

// Transform the implicit coroutine statements constructed using dependent
// types during the previous parse: initial and final suspensions, the return
// object, and others. We also transform the coroutine function's body.
StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
if (InitSuspend.isInvalid())
  return StmtError();
StmtResult FinalSuspend =
    getDerived().TransformStmt(S->getFinalSuspendStmt());
if (FinalSuspend.isInvalid() ||
    !SemaRef.checkFinalSuspendNoThrow(FinalSuspend.get()))
  return StmtError();
ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()))(static_cast <bool> (isa<Expr>(InitSuspend.get())
 && isa<Expr>(FinalSuspend.get())) ? void (0) :
 __assert_fail ("isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get())"
, "clang/lib/Sema/TreeTransform.h", 8038, __extension__ __PRETTY_FUNCTION__
));

StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
if (BodyRes.isInvalid())
  return StmtError();

CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
if (Builder.isInvalid())
  return StmtError();

Expr *ReturnObject = S->getReturnValueInit();
assert(ReturnObject && "the return object is expected to be valid")(static_cast <bool> (ReturnObject && "the return object is expected to be valid"
) ? void (0) : __assert_fail ("ReturnObject && \"the return object is expected to be valid\""
, "clang/lib/Sema/TreeTransform.h", 8049, __extension__ __PRETTY_FUNCTION__
));
ExprResult Res = getDerived().TransformInitializer(ReturnObject,
                                                   /*NoCopyInit*/ false);
if (Res.isInvalid())
  return StmtError();
Builder.ReturnValue = Res.get();

// If during the previous parse the coroutine still had a dependent promise
// statement, we may need to build some implicit coroutine statements
// (such as exception and fallthrough handlers) for the first time.
if (S->hasDependentPromiseType()) {
  // We can only build these statements, however, if the current promise type
  // is not dependent.
  if (!Promise->getType()->isDependentType()) {
    assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&(static_cast <bool> (!S->getFallthroughHandler() &&
 !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure
() && !S->getDeallocate() && "these nodes should not have been built yet"
) ? void (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "clang/lib/Sema/TreeTransform.h", 8065, __extension__ __PRETTY_FUNCTION__
))
           !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&(static_cast <bool> (!S->getFallthroughHandler() &&
 !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure
() && !S->getDeallocate() && "these nodes should not have been built yet"
) ? void (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "clang/lib/Sema/TreeTransform.h", 8065, __extension__ __PRETTY_FUNCTION__
))
           "these nodes should not have been built yet")(static_cast <bool> (!S->getFallthroughHandler() &&
 !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure
() && !S->getDeallocate() && "these nodes should not have been built yet"
) ? void (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "clang/lib/Sema/TreeTransform.h", 8065, __extension__ __PRETTY_FUNCTION__
));
    if (!Builder.buildDependentStatements())
      return StmtError();
  }
} else {
  if (auto *OnFallthrough = S->getFallthroughHandler()) {
    StmtResult Res = getDerived().TransformStmt(OnFallthrough);
    if (Res.isInvalid())
      return StmtError();
    Builder.OnFallthrough = Res.get();
  }

  if (auto *OnException = S->getExceptionHandler()) {
    StmtResult Res = getDerived().TransformStmt(OnException);
    if (Res.isInvalid())
      return StmtError();
    Builder.OnException = Res.get();
  }

  if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
    StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
    if (Res.isInvalid())
      return StmtError();
    Builder.ReturnStmtOnAllocFailure = Res.get();
  }

  // Transform any additional statements we may have already built
  assert(S->getAllocate() && S->getDeallocate() &&(static_cast <bool> (S->getAllocate() && S->
getDeallocate() && "allocation and deallocation calls must already be built"
) ? void (0) : __assert_fail ("S->getAllocate() && S->getDeallocate() && \"allocation and deallocation calls must already be built\""
, "clang/lib/Sema/TreeTransform.h", 8093, __extension__ __PRETTY_FUNCTION__
))
         "allocation and deallocation calls must already be built")(static_cast <bool> (S->getAllocate() && S->
getDeallocate() && "allocation and deallocation calls must already be built"
) ? void (0) : __assert_fail ("S->getAllocate() && S->getDeallocate() && \"allocation and deallocation calls must already be built\""
, "clang/lib/Sema/TreeTransform.h", 8093, __extension__ __PRETTY_FUNCTION__
));
  ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
  if (AllocRes.isInvalid())
    return StmtError();
  Builder.Allocate = AllocRes.get();

  ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
  if (DeallocRes.isInvalid())
    return StmtError();
  Builder.Deallocate = DeallocRes.get();

  if (auto *ResultDecl = S->getResultDecl()) {
    StmtResult Res = getDerived().TransformStmt(ResultDecl);
    if (Res.isInvalid())
      return StmtError();
    Builder.ResultDecl = Res.get();
  }

  if (auto *ReturnStmt = S->getReturnStmt()) {
    StmtResult Res = getDerived().TransformStmt(ReturnStmt);
    if (Res.isInvalid())
      return StmtError();
    Builder.ReturnStmt = Res.get();
  }
}

return getDerived().RebuildCoroutineBodyStmt(Builder);
8120}

8122template<typename Derived>
8123StmtResult
8124TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return StmtError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
                                        S->isImplicit());
8134}

8136template <typename Derived>
8137ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
ExprResult Operand = getDerived().TransformInitializer(E->getOperand(),
                                                       /*NotCopyInit*/ false);
if (Operand.isInvalid())
  return ExprError();

// Rebuild the common-expr from the operand rather than transforming it
// separately.

// FIXME: getCurScope() should not be used during template instantiation.
// We should pick up the set of unqualified lookup results for operator
// co_await during the initial parse.
ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
    getSema().getCurScope(), E->getKeywordLoc());

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoawaitExpr(
    E->getKeywordLoc(), Operand.get(),
    cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit());
8157}

8159template <typename Derived>
8160ExprResult
8161TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) {
ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/ false);
if (OperandResult.isInvalid())
  return ExprError();

ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
        E->getOperatorCoawaitLookup());

if (LookupResult.isInvalid())
  return ExprError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildDependentCoawaitExpr(
    E->getKeywordLoc(), OperandResult.get(),
    cast<UnresolvedLookupExpr>(LookupResult.get()));
8178}

8180template<typename Derived>
8181ExprResult
8182TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return ExprError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
8191}

8193// Objective-C Statements.

8195template<typename Derived>
8196StmtResult
8197TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
// Transform the body of the @try.
StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
if (TryBody.isInvalid())
  return StmtError();

// Transform the @catch statements (if present).
bool AnyCatchChanged = false;
SmallVector<Stmt*, 8> CatchStmts;
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
  StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
  if (Catch.isInvalid())
    return StmtError();
  if (Catch.get() != S->getCatchStmt(I))
    AnyCatchChanged = true;
  CatchStmts.push_back(Catch.get());
}

// Transform the @finally statement (if present).
StmtResult Finally;
if (S->getFinallyStmt()) {
  Finally = getDerived().TransformStmt(S->getFinallyStmt());
  if (Finally.isInvalid())
    return StmtError();
}

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    TryBody.get() == S->getTryBody() &&
    !AnyCatchChanged &&
    Finally.get() == S->getFinallyStmt())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
                                         CatchStmts, Finally.get());
8233}

8235template<typename Derived>
8236StmtResult
8237TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
// Transform the @catch parameter, if there is one.
VarDecl *Var = nullptr;
if (VarDecl *FromVar = S->getCatchParamDecl()) {
  TypeSourceInfo *TSInfo = nullptr;
  if (FromVar->getTypeSourceInfo()) {
    TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
    if (!TSInfo)
      return StmtError();
  }

  QualType T;
  if (TSInfo)
    T = TSInfo->getType();
  else {
    T = getDerived().TransformType(FromVar->getType());
    if (T.isNull())
      return StmtError();
  }

  Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
  if (!Var)
    return StmtError();
}

StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
if (Body.isInvalid())
  return StmtError();

return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
                                           S->getRParenLoc(),
                                           Var, Body.get());
8269}

8271template<typename Derived>
8272StmtResult
8273TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Body.get() == S->getFinallyBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
                                             Body.get());
8287}

8289template<typename Derived>
8290StmtResult
8291TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
ExprResult Operand;
if (S->getThrowExpr()) {
  Operand = getDerived().TransformExpr(S->getThrowExpr());
  if (Operand.isInvalid())
    return StmtError();
}

if (!getDerived().AlwaysRebuild() &&
    Operand.get() == S->getThrowExpr())
  return S;

return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
8304}

8306template<typename Derived>
8307StmtResult
8308TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
                                                ObjCAtSynchronizedStmt *S) {
// Transform the object we are locking.
ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
if (Object.isInvalid())
  return StmtError();
Object =
  getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
                                                Object.get());
if (Object.isInvalid())
  return StmtError();

// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
if (Body.isInvalid())
  return StmtError();

// If nothing change, just retain the current statement.
if (!getDerived().AlwaysRebuild() &&
    Object.get() == S->getSynchExpr() &&
    Body.get() == S->getSynchBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
                                                  Object.get(), Body.get());
8334}

8336template<typename Derived>
8337StmtResult
8338TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
                                            ObjCAutoreleasePoolStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Body.get() == S->getSubStmt())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAutoreleasePoolStmt(
                      S->getAtLoc(), Body.get());
8353}

8355template<typename Derived>
8356StmtResult
8357TreeTransform<Derived>::TransformObjCForCollectionStmt(
                                                ObjCForCollectionStmt *S) {
// Transform the element statement.
StmtResult Element =
    getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
if (Element.isInvalid())
  return StmtError();

// Transform the collection expression.
ExprResult Collection = getDerived().TransformExpr(S->getCollection());
if (Collection.isInvalid())
  return StmtError();

// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Element.get() == S->getElement() &&
    Collection.get() == S->getCollection() &&
    Body.get() == S->getBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
                                                 Element.get(),
                                                 Collection.get(),
                                                 S->getRParenLoc(),
                                                 Body.get());
8388}

8390template <typename Derived>
8391StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
// Transform the exception declaration, if any.
VarDecl *Var = nullptr;
if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
  TypeSourceInfo *T =
      getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
  if (!T)
    return StmtError();

  Var = getDerived().RebuildExceptionDecl(
      ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
      ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
  if (!Var || Var->isInvalidDecl())
    return StmtError();
}

// Transform the actual exception handler.
StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
if (Handler.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() && !Var &&
    Handler.get() == S->getHandlerBlock())
  return S;

return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
8417}

8419template <typename Derived>
8420StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
// Transform the try block itself.
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
  return StmtError();

// Transform the handlers.
bool HandlerChanged = false;
SmallVector<Stmt *, 8> Handlers;
for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
  StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
  if (Handler.isInvalid())
    return StmtError();

  HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
  Handlers.push_back(Handler.getAs<Stmt>());
}

if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
    !HandlerChanged)
  return S;

return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
                                      Handlers);
8444}

8446template<typename Derived>
8447StmtResult
8448TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
StmtResult Init =
    S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
if (Init.isInvalid())
  return StmtError();

StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
if (Range.isInvalid())
  return StmtError();

StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
if (Begin.isInvalid())
  return StmtError();
StmtResult End = getDerived().TransformStmt(S->getEndStmt());
if (End.isInvalid())
  return StmtError();

ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
  return StmtError();
if (Cond.get())
  Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
if (Cond.isInvalid())
  return StmtError();
if (Cond.get())
  Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());

ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
  return StmtError();
if (Inc.get())
  Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());

StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
if (LoopVar.isInvalid())
  return StmtError();

StmtResult NewStmt = S;
if (getDerived().AlwaysRebuild() ||
    Init.get() != S->getInit() ||
    Range.get() != S->getRangeStmt() ||
    Begin.get() != S->getBeginStmt() ||
    End.get() != S->getEndStmt() ||
    Cond.get() != S->getCond() ||
    Inc.get() != S->getInc() ||
    LoopVar.get() != S->getLoopVarStmt()) {
  NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
                                                S->getCoawaitLoc(), Init.get(),
                                                S->getColonLoc(), Range.get(),
                                                Begin.get(), End.get(),
                                                Cond.get(),
                                                Inc.get(), LoopVar.get(),
                                                S->getRParenLoc());
  if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
    // Might not have attached any initializer to the loop variable.
    getSema().ActOnInitializerError(
        cast<DeclStmt>(LoopVar.get())->getSingleDecl());
    return StmtError();
  }
}

StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Body has changed but we didn't rebuild the for-range statement. Rebuild
// it now so we have a new statement to attach the body to.
if (Body.get() != S->getBody() && NewStmt.get() == S) {
  NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
                                                S->getCoawaitLoc(), Init.get(),
                                                S->getColonLoc(), Range.get(),
                                                Begin.get(), End.get(),
                                                Cond.get(),
                                                Inc.get(), LoopVar.get(),
                                                S->getRParenLoc());
  if (NewStmt.isInvalid())
    return StmtError();
}

if (NewStmt.get() == S)
  return S;

return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
8531}

8533template<typename Derived>
8534StmtResult
8535TreeTransform<Derived>::TransformMSDependentExistsStmt(
                                                  MSDependentExistsStmt *S) {
// Transform the nested-name-specifier, if any.
NestedNameSpecifierLoc QualifierLoc;
if (S->getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
  if (!QualifierLoc)
    return StmtError();
}

// Transform the declaration name.
DeclarationNameInfo NameInfo = S->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return StmtError();
}

// Check whether anything changed.
if (!getDerived().AlwaysRebuild() &&
    QualifierLoc == S->getQualifierLoc() &&
    NameInfo.getName() == S->getNameInfo().getName())
  return S;

// Determine whether this name exists, if we can.
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
bool Dependent = false;
switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
case Sema::IER_Exists:
  if (S->isIfExists())
    break;

  return new (getSema().Context) NullStmt(S->getKeywordLoc());

case Sema::IER_DoesNotExist:
  if (S->isIfNotExists())
    break;

  return new (getSema().Context) NullStmt(S->getKeywordLoc());

case Sema::IER_Dependent:
  Dependent = true;
  break;

case Sema::IER_Error:
  return StmtError();
}

// We need to continue with the instantiation, so do so now.
StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// If we have resolved the name, just transform to the substatement.
if (!Dependent)
  return SubStmt;

// The name is still dependent, so build a dependent expression again.
return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
                                                 S->isIfExists(),
                                                 QualifierLoc,
                                                 NameInfo,
                                                 SubStmt.get());
8600}

8602template<typename Derived>
8603ExprResult
8604TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifierLoc()) {
  QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
  getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
if (!PD)
  return ExprError();

ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
  return ExprError();

return new (SemaRef.getASTContext())
    MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
                      SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
                      QualifierLoc, E->getMemberLoc());
8626}

8628template <typename Derived>
8629ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
  MSPropertySubscriptExpr *E) {
auto BaseRes = getDerived().TransformExpr(E->getBase());
if (BaseRes.isInvalid())
  return ExprError();
auto IdxRes = getDerived().TransformExpr(E->getIdx());
if (IdxRes.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    BaseRes.get() == E->getBase() &&
    IdxRes.get() == E->getIdx())
  return E;

return getDerived().RebuildArraySubscriptExpr(
    BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
8645}

8647template <typename Derived>
8648StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
  return StmtError();

StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
if (Handler.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
    Handler.get() == S->getHandler())
  return S;

return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
                                      TryBlock.get(), Handler.get());
8663}

8665template <typename Derived>
8666StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
  return StmtError();

return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
8672}

8674template <typename Derived>
8675StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
if (FilterExpr.isInvalid())
  return StmtError();

StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
  return StmtError();

return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
                                         Block.get());
8686}

8688template <typename Derived>
8689StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
if (isa<SEHFinallyStmt>(Handler))
  return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
else
  return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
8694}

8696template<typename Derived>
8697StmtResult
8698TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
return S;
8700}

8702//===----------------------------------------------------------------------===//
8703// OpenMP directive transformation
8704//===----------------------------------------------------------------------===//

8706template <typename Derived>
8707StmtResult
8708TreeTransform<Derived>::TransformOMPCanonicalLoop(OMPCanonicalLoop *L) {
// OMPCanonicalLoops are eliminated during transformation, since they will be
// recomputed by semantic analysis of the associated OMPLoopBasedDirective
// after transformation.
return getDerived().TransformStmt(L->getLoopStmt());
8713}

8715template <typename Derived>
8716StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
  OMPExecutableDirective *D) {

// Transform the clauses
llvm::SmallVector<OMPClause *, 16> TClauses;
ArrayRef<OMPClause *> Clauses = D->clauses();
TClauses.reserve(Clauses.size());
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
     I != E; ++I) {
  if (*I) {
    getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
    OMPClause *Clause = getDerived().TransformOMPClause(*I);
    getDerived().getSema().EndOpenMPClause();
    if (Clause)
      TClauses.push_back(Clause);
  } else {
    TClauses.push_back(nullptr);
  }
}
StmtResult AssociatedStmt;
if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
  getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(),
                                                /*CurScope=*/nullptr);
  StmtResult Body;
  {
    Sema::CompoundScopeRAII CompoundScope(getSema());
    Stmt *CS;
    if (D->getDirectiveKind() == OMPD_atomic ||
        D->getDirectiveKind() == OMPD_critical ||
        D->getDirectiveKind() == OMPD_section ||
        D->getDirectiveKind() == OMPD_master)
      CS = D->getAssociatedStmt();
    else
      CS = D->getRawStmt();
    Body = getDerived().TransformStmt(CS);
    if (Body.isUsable() && isOpenMPLoopDirective(D->getDirectiveKind()) &&
        getSema().getLangOpts().OpenMPIRBuilder)
      Body = getDerived().RebuildOMPCanonicalLoop(Body.get());
  }
  AssociatedStmt =
      getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
  if (AssociatedStmt.isInvalid()) {
    return StmtError();
  }
}
if (TClauses.size() != Clauses.size()) {
  return StmtError();
}

// Transform directive name for 'omp critical' directive.
DeclarationNameInfo DirName;
if (D->getDirectiveKind() == OMPD_critical) {
  DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
  DirName = getDerived().TransformDeclarationNameInfo(DirName);
}
OpenMPDirectiveKind CancelRegion = OMPD_unknown;
if (D->getDirectiveKind() == OMPD_cancellation_point) {
  CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
} else if (D->getDirectiveKind() == OMPD_cancel) {
  CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
}

return getDerived().RebuildOMPExecutableDirective(
    D->getDirectiveKind(), DirName, CancelRegion, TClauses,
    AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc());
8781}

8783template <typename Derived>
8784StmtResult
8785TreeTransform<Derived>::TransformOMPMetaDirective(OMPMetaDirective *D) {
// TODO: Fix This
SemaRef.Diag(D->getBeginLoc(), diag::err_omp_instantiation_not_supported)
    << getOpenMPDirectiveName(D->getDirectiveKind());
return StmtError();
8790}

8792template <typename Derived>
8793StmtResult
8794TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8801}

8803template <typename Derived>
8804StmtResult
8805TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8812}

8814template <typename Derived>
8815StmtResult
8816TreeTransform<Derived>::TransformOMPTileDirective(OMPTileDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(D->getDirectiveKind(), DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8823}

8825template <typename Derived>
8826StmtResult
8827TreeTransform<Derived>::TransformOMPUnrollDirective(OMPUnrollDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(D->getDirectiveKind(), DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8834}

8836template <typename Derived>
8837StmtResult
8838TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8845}

8847template <typename Derived>
8848StmtResult
8849TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8856}

8858template <typename Derived>
8859StmtResult
8860TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8867}

8869template <typename Derived>
8870StmtResult
8871TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8878}

8880template <typename Derived>
8881StmtResult
8882TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8889}

8891template <typename Derived>
8892StmtResult
8893TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8900}

8902template <typename Derived>
8903StmtResult
8904TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8910}

8912template <typename Derived>
8913StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
  OMPParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8921}

8923template <typename Derived>
8924StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
  OMPParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8932}

8934template <typename Derived>
8935StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective(
  OMPParallelMasterDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_master, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8943}

8945template <typename Derived>
8946StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective(
  OMPParallelMaskedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_masked, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8954}

8956template <typename Derived>
8957StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
  OMPParallelSectionsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8965}

8967template <typename Derived>
8968StmtResult
8969TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8976}

8978template <typename Derived>
8979StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
  OMPTaskyieldDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8987}

8989template <typename Derived>
8990StmtResult
8991TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8998}

9000template <typename Derived>
9001StmtResult
9002TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9009}

9011template <typename Derived>
9012StmtResult
9013TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_error, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9020}

9022template <typename Derived>
9023StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
  OMPTaskgroupDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9031}

9033template <typename Derived>
9034StmtResult
9035TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9042}

9044template <typename Derived>
9045StmtResult
9046TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_depobj, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9053}

9055template <typename Derived>
9056StmtResult
9057TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_scan, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9064}

9066template <typename Derived>
9067StmtResult
9068TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9075}

9077template <typename Derived>
9078StmtResult
9079TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9086}

9088template <typename Derived>
9089StmtResult
9090TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9097}

9099template <typename Derived>
9100StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
  OMPTargetDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9108}

9110template <typename Derived>
9111StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
  OMPTargetEnterDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9119}

9121template <typename Derived>
9122StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
  OMPTargetExitDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9130}

9132template <typename Derived>
9133StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
  OMPTargetParallelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9141}

9143template <typename Derived>
9144StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
  OMPTargetParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9152}

9154template <typename Derived>
9155StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
  OMPTargetUpdateDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9163}

9165template <typename Derived>
9166StmtResult
9167TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9174}

9176template <typename Derived>
9177StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
  OMPCancellationPointDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9185}

9187template <typename Derived>
9188StmtResult
9189TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9196}

9198template <typename Derived>
9199StmtResult
9200TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9207}

9209template <typename Derived>
9210StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
  OMPTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9218}

9220template <typename Derived>
9221StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective(
  OMPMasterTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master_taskloop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9229}

9231template <typename Derived>
9232StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective(
  OMPMaskedTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9240}

9242template <typename Derived>
9243StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
  OMPMasterTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9251}

9253template <typename Derived>
9254StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
  OMPMaskedTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9262}

9264template <typename Derived>
9265StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
  OMPParallelMasterTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_master_taskloop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9273}

9275template <typename Derived>
9276StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective(
  OMPParallelMaskedTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_masked_taskloop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9284}

9286template <typename Derived>
9287StmtResult
9288TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective(
  OMPParallelMasterTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9296}

9298template <typename Derived>
9299StmtResult
9300TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective(
  OMPParallelMaskedTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9308}

9310template <typename Derived>
9311StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
  OMPDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9319}

9321template <typename Derived>
9322StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
  OMPDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9330}

9332template <typename Derived>
9333StmtResult
9334TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
  OMPDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9342}

9344template <typename Derived>
9345StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
  OMPDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9353}

9355template <typename Derived>
9356StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
  OMPTargetParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9364}

9366template <typename Derived>
9367StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
  OMPTargetSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9375}

9377template <typename Derived>
9378StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
  OMPTeamsDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9386}

9388template <typename Derived>
9389StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
  OMPTeamsDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9397}

9399template <typename Derived>
9400StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
  OMPTeamsDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_parallel_for_simd, DirName, nullptr,
    D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9409}

9411template <typename Derived>
9412StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
  OMPTeamsDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9420}

9422template <typename Derived>
9423StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
  OMPTargetTeamsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams, DirName,
                                           nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9431}

9433template <typename Derived>
9434StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
  OMPTargetTeamsDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9442}

9444template <typename Derived>
9445StmtResult
9446TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
  OMPTargetTeamsDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_parallel_for, DirName, nullptr,
    D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9455}

9457template <typename Derived>
9458StmtResult TreeTransform<Derived>::
  TransformOMPTargetTeamsDistributeParallelForSimdDirective(
      OMPTargetTeamsDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr,
    D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9468}

9470template <typename Derived>
9471StmtResult
9472TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
  OMPTargetTeamsDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9480}

9482template <typename Derived>
9483StmtResult
9484TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_interop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9491}

9493template <typename Derived>
9494StmtResult
9495TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_dispatch, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9502}

9504template <typename Derived>
9505StmtResult
9506TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9513}

9515template <typename Derived>
9516StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective(
  OMPGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_loop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9524}

9526template <typename Derived>
9527StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective(
  OMPTeamsGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_loop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9535}

9537template <typename Derived>
9538StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective(
  OMPTargetTeamsGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams_loop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9546}

9548template <typename Derived>
9549StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective(
  OMPParallelGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_loop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9557}

9559template <typename Derived>
9560StmtResult
9561TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective(
  OMPTargetParallelGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_loop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9569}

9571//===----------------------------------------------------------------------===//
9572// OpenMP clause transformation
9573//===----------------------------------------------------------------------===//
9574template <typename Derived>
9575OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPIfClause(
    C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc());
9582}

9584template <typename Derived>
9585OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
9591}

9593template <typename Derived>
9594OMPClause *
9595TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
if (NumThreads.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumThreadsClause(
    NumThreads.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9601}

9603template <typename Derived>
9604OMPClause *
9605TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSafelen());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPSafelenClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9611}

9613template <typename Derived>
9614OMPClause *
9615TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *C) {
ExprResult E = getDerived().TransformExpr(C->getAllocator());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAllocatorClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9621}

9623template <typename Derived>
9624OMPClause *
9625TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSimdlen());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPSimdlenClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9631}

9633template <typename Derived>
9634OMPClause *TreeTransform<Derived>::TransformOMPSizesClause(OMPSizesClause *C) {
SmallVector<Expr *, 4> TransformedSizes;
TransformedSizes.reserve(C->getNumSizes());
bool Changed = false;
for (Expr *E : C->getSizesRefs()) {
  if (!E) {
    TransformedSizes.push_back(nullptr);
    continue;
  }

  ExprResult T = getDerived().TransformExpr(E);
  if (T.isInvalid())
    return nullptr;
  if (E != T.get())
    Changed = true;
  TransformedSizes.push_back(T.get());
}

if (!Changed && !getDerived().AlwaysRebuild())
  return C;
return RebuildOMPSizesClause(TransformedSizes, C->getBeginLoc(),
                             C->getLParenLoc(), C->getEndLoc());
9656}

9658template <typename Derived>
9659OMPClause *TreeTransform<Derived>::TransformOMPFullClause(OMPFullClause *C) {
if (!getDerived().AlwaysRebuild())
  return C;
return RebuildOMPFullClause(C->getBeginLoc(), C->getEndLoc());
9663}

9665template <typename Derived>
9666OMPClause *
9667TreeTransform<Derived>::TransformOMPPartialClause(OMPPartialClause *C) {
ExprResult T = getDerived().TransformExpr(C->getFactor());
if (T.isInvalid())
  return nullptr;
Expr *Factor = T.get();
bool Changed = Factor != C->getFactor();

if (!Changed && !getDerived().AlwaysRebuild())
  return C;
return RebuildOMPPartialClause(Factor, C->getBeginLoc(), C->getLParenLoc(),
                               C->getEndLoc());
9678}

9680template <typename Derived>
9681OMPClause *
9682TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPCollapseClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9688}

9690template <typename Derived>
9691OMPClause *
9692TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
return getDerived().RebuildOMPDefaultClause(
    C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
9696}

9698template <typename Derived>
9699OMPClause *
9700TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
return getDerived().RebuildOMPProcBindClause(
    C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
9704}

9706template <typename Derived>
9707OMPClause *
9708TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
ExprResult E = getDerived().TransformExpr(C->getChunkSize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPScheduleClause(
    C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
    C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
    C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
9717}

9719template <typename Derived>
9720OMPClause *
9721TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
ExprResult E;
if (auto *Num = C->getNumForLoops()) {
  E = getDerived().TransformExpr(Num);
  if (E.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(),
                                            C->getLParenLoc(), E.get());
9730}

9732template <typename Derived>
9733OMPClause *
9734TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *C) {
ExprResult E;
if (Expr *Evt = C->getEventHandler()) {
  E = getDerived().TransformExpr(Evt);
  if (E.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
9743}

9745template <typename Derived>
9746OMPClause *
9747TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9750}

9752template <typename Derived>
9753OMPClause *
9754TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9757}

9759template <typename Derived>
9760OMPClause *
9761TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9764}

9766template <typename Derived>
9767OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9770}

9772template <typename Derived>
9773OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9776}

9778template <typename Derived>
9779OMPClause *
9780TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9783}

9785template <typename Derived>
9786OMPClause *
9787TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9790}

9792template <typename Derived>
9793OMPClause *
9794TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9797}

9799template <typename Derived>
9800OMPClause *
9801TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9804}

9806template <typename Derived>
9807OMPClause *
9808TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9811}

9813template <typename Derived>
9814OMPClause *
9815TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9818}

9820template <typename Derived>
9821OMPClause *
9822TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9825}

9827template <typename Derived>
9828OMPClause *
9829TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9832}

9834template <typename Derived>
9835OMPClause *
9836TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9839}

9841template <typename Derived>
9842OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9845}

9847template <typename Derived>
9848OMPClause *
9849TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9852}

9854template <typename Derived>
9855OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *C) {
ExprResult IVR = getDerived().TransformExpr(C->getInteropVar());
if (IVR.isInvalid())
  return nullptr;

OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync());
InteropInfo.PreferTypes.reserve(C->varlist_size() - 1);
for (Expr *E : llvm::drop_begin(C->varlists())) {
  ExprResult ER = getDerived().TransformExpr(cast<Expr>(E));
  if (ER.isInvalid())
    return nullptr;
  InteropInfo.PreferTypes.push_back(ER.get());
}
return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo,
                                         C->getBeginLoc(), C->getLParenLoc(),
                                         C->getVarLoc(), C->getEndLoc());
9871}

9873template <typename Derived>
9874OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *C) {
ExprResult ER = getDerived().TransformExpr(C->getInteropVar());
if (ER.isInvalid())
  return nullptr;
return getDerived().RebuildOMPUseClause(ER.get(), C->getBeginLoc(),
                                        C->getLParenLoc(), C->getVarLoc(),
                                        C->getEndLoc());
9881}

9883template <typename Derived>
9884OMPClause *
9885TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *C) {
ExprResult ER;
if (Expr *IV = C->getInteropVar()) {
  ER = getDerived().TransformExpr(IV);
  if (ER.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPDestroyClause(ER.get(), C->getBeginLoc(),
                                            C->getLParenLoc(), C->getVarLoc(),
                                            C->getEndLoc());
9895}

9897template <typename Derived>
9898OMPClause *
9899TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNovariantsClause(
    Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9905}

9907template <typename Derived>
9908OMPClause *
9909TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNocontextClause(
    Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9915}

9917template <typename Derived>
9918OMPClause *
9919TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) {
ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID());
if (ThreadID.isInvalid())
  return nullptr;
return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
9925}

9927template <typename Derived>
9928OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *C) {
ExprResult E = getDerived().TransformExpr(C->getAlignment());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
9934}

9936template <typename Derived>
9937OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
  OMPUnifiedAddressClause *C) {
llvm_unreachable("unified_address clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("unified_address clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9939);
9940}

9942template <typename Derived>
9943OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
  OMPUnifiedSharedMemoryClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("unified_shared_memory clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9946)
    "unified_shared_memory clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("unified_shared_memory clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9946);
9947}

9949template <typename Derived>
9950OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
  OMPReverseOffloadClause *C) {
llvm_unreachable("reverse_offload clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("reverse_offload clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9952);
9953}

9955template <typename Derived>
9956OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
  OMPDynamicAllocatorsClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("dynamic_allocators clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9959)
    "dynamic_allocators clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("dynamic_allocators clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9959);
9960}

9962template <typename Derived>
9963OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
  OMPAtomicDefaultMemOrderClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("atomic_default_mem_order clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9966)
    "atomic_default_mem_order clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("atomic_default_mem_order clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9966);
9967}

9969template <typename Derived>
9970OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *C) {
return getDerived().RebuildOMPAtClause(C->getAtKind(), C->getAtKindKwLoc(),
                                       C->getBeginLoc(), C->getLParenLoc(),
                                       C->getEndLoc());
9974}

9976template <typename Derived>
9977OMPClause *
9978TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *C) {
return getDerived().RebuildOMPSeverityClause(
    C->getSeverityKind(), C->getSeverityKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
9982}

9984template <typename Derived>
9985OMPClause *
9986TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) {
ExprResult E = getDerived().TransformExpr(C->getMessageString());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPMessageClause(
    C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(),
    C->getEndLoc());
9993}

9995template <typename Derived>
9996OMPClause *
9997TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPPrivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10008}

10010template <typename Derived>
10011OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
  OMPFirstprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPFirstprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10023}

10025template <typename Derived>
10026OMPClause *
10027TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPLastprivateClause(
    Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
10039}

10041template <typename Derived>
10042OMPClause *
10043TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
10054}

10056template <typename Derived>
10057OMPClause *
10058TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(
     UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
        NameInfo, /*ADL=*/true, ULE->isOverloaded(),
        Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPReductionClause(
    Vars, C->getModifier(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getColonLoc(), C->getEndLoc(),
    ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10102}

10104template <typename Derived>
10105OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
  OMPTaskReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
        /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPTaskReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10147}

10149template <typename Derived>
10150OMPClause *
10151TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
        /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPInReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10192}

10194template <typename Derived>
10195OMPClause *
10196TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
ExprResult Step = getDerived().TransformExpr(C->getStep());
if (Step.isInvalid())
  return nullptr;
return getDerived().RebuildOMPLinearClause(
    Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(),
    C->getModifierLoc(), C->getColonLoc(), C->getEndLoc());
10211}

10213template <typename Derived>
10214OMPClause *
10215TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
if (Alignment.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAlignedClause(
    Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getColonLoc(), C->getEndLoc());
10230}

10232template <typename Derived>
10233OMPClause *
10234TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
10245}

10247template <typename Derived>
10248OMPClause *
10249TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10260}

10262template <typename Derived>
10263OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
10274}

10276template <typename Derived>
10277OMPClause *
10278TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *C) {
ExprResult E = getDerived().TransformExpr(C->getDepobj());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDepobjClause(E.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
10284}

10286template <typename Derived>
10287OMPClause *
10288TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Expr *DepModifier = C->getModifier();
if (DepModifier) {
  ExprResult DepModRes = getDerived().TransformExpr(DepModifier);
  if (DepModRes.isInvalid())
    return nullptr;
  DepModifier = DepModRes.get();
}
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPDependClause(
    {C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(),
     C->getOmpAllMemoryLoc()},
    DepModifier, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10308}

10310template <typename Derived>
10311OMPClause *
10312TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
ExprResult E = getDerived().TransformExpr(C->getDevice());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDeviceClause(
    C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getEndLoc());
10319}

10321template <typename Derived, class T>
10322bool transformOMPMappableExprListClause(
  TreeTransform<Derived> &TT, OMPMappableExprListClause<T> *C,
  llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec,
  DeclarationNameInfo &MapperIdInfo,
  llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) {
// Transform expressions in the list.
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return true;
  Vars.push_back(EVar.get());
}
// Transform mapper scope specifier and identifier.
NestedNameSpecifierLoc QualifierLoc;
if (C->getMapperQualifierLoc()) {
  QualifierLoc = TT.getDerived().TransformNestedNameSpecifierLoc(
      C->getMapperQualifierLoc());
  if (!QualifierLoc)
    return true;
}
MapperIdScopeSpec.Adopt(QualifierLoc);
MapperIdInfo = C->getMapperIdInfo();
if (MapperIdInfo.getName()) {
  MapperIdInfo = TT.getDerived().TransformDeclarationNameInfo(MapperIdInfo);
  if (!MapperIdInfo.getName())
    return true;
}
// Build a list of all candidate OMPDeclareMapperDecls, which is provided by
// the previous user-defined mapper lookup in dependent environment.
for (auto *E : C->mapperlists()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedMappers.push_back(UnresolvedLookupExpr::Create(
        TT.getSema().Context, /*NamingClass=*/nullptr,
        MapperIdScopeSpec.getWithLocInContext(TT.getSema().Context),
        MapperIdInfo, /*ADL=*/true, ULE->isOverloaded(), Decls.begin(),
        Decls.end()));
  } else {
    UnresolvedMappers.push_back(nullptr);
  }
}
return false;
10372}

10374template <typename Derived>
10375OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
Expr *IteratorModifier = C->getIteratorModifier();
if (IteratorModifier) {
  ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
  if (MapModRes.isInvalid())
    return nullptr;
  IteratorModifier = MapModRes.get();
}
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPMapClause(
    IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(),
    MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(),
    C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10395}

10397template <typename Derived>
10398OMPClause *
10399TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) {
Expr *Allocator = C->getAllocator();
if (Allocator) {
  ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
  if (AllocatorRes.isInvalid())
    return nullptr;
  Allocator = AllocatorRes.get();
}
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPAllocateClause(
    Allocator, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc());
10418}

10420template <typename Derived>
10421OMPClause *
10422TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTeams());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumTeamsClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10428}

10430template <typename Derived>
10431OMPClause *
10432TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPThreadLimitClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10438}

10440template <typename Derived>
10441OMPClause *
10442TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
ExprResult E = getDerived().TransformExpr(C->getPriority());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPPriorityClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10448}

10450template <typename Derived>
10451OMPClause *
10452TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
ExprResult E = getDerived().TransformExpr(C->getGrainsize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPGrainsizeClause(
    C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getEndLoc());
10459}

10461template <typename Derived>
10462OMPClause *
10463TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTasks());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumTasksClause(
    C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getEndLoc());
10470}

10472template <typename Derived>
10473OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
ExprResult E = getDerived().TransformExpr(C->getHint());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(),
                                         C->getLParenLoc(), C->getEndLoc());
10479}

10481template <typename Derived>
10482OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
  OMPDistScheduleClause *C) {
ExprResult E = getDerived().TransformExpr(C->getChunkSize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDistScheduleClause(
    C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
10490}

10492template <typename Derived>
10493OMPClause *
10494TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) {
// Rebuild Defaultmap Clause since we need to invoke the checking of
// defaultmap(none:variable-category) after template initialization.
return getDerived().RebuildOMPDefaultmapClause(C->getDefaultmapModifier(),
                                               C->getDefaultmapKind(),
                                               C->getBeginLoc(),
                                               C->getLParenLoc(),
                                               C->getDefaultmapModifierLoc(),
                                               C->getDefaultmapKindLoc(),
                                               C->getEndLoc());
10504}

10506template <typename Derived>
10507OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPToClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPToClause(
    C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
    MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10519}

10521template <typename Derived>
10522OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPFromClause(
    C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
    MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10534}

10536template <typename Derived>
10537OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
  OMPUseDevicePtrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPUseDevicePtrClause(Vars, Locs);
10549}

10551template <typename Derived>
10552OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause(
  OMPUseDeviceAddrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs);
10564}

10566template <typename Derived>
10567OMPClause *
10568TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
10579}

10581template <typename Derived>
10582OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause(
  OMPHasDeviceAddrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs);
10594}

10596template <typename Derived>
10597OMPClause *
10598TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPNontemporalClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10609}

10611template <typename Derived>
10612OMPClause *
10613TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPInclusiveClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10624}

10626template <typename Derived>
10627OMPClause *
10628TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPExclusiveClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10639}

10641template <typename Derived>
10642OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause(
  OMPUsesAllocatorsClause *C) {
SmallVector<Sema::UsesAllocatorsData, 16> Data;
Data.reserve(C->getNumberOfAllocators());
for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
  OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
  ExprResult Allocator = getDerived().TransformExpr(D.Allocator);
  if (Allocator.isInvalid())
    continue;
  ExprResult AllocatorTraits;
  if (Expr *AT = D.AllocatorTraits) {
    AllocatorTraits = getDerived().TransformExpr(AT);
    if (AllocatorTraits.isInvalid())
      continue;
  }
  Sema::UsesAllocatorsData &NewD = Data.emplace_back();
  NewD.Allocator = Allocator.get();
  NewD.AllocatorTraits = AllocatorTraits.get();
  NewD.LParenLoc = D.LParenLoc;
  NewD.RParenLoc = D.RParenLoc;
}
return getDerived().RebuildOMPUsesAllocatorsClause(
    Data, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10665}

10667template <typename Derived>
10668OMPClause *
10669TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) {
SmallVector<Expr *, 4> Locators;
Locators.reserve(C->varlist_size());
ExprResult ModifierRes;
if (Expr *Modifier = C->getModifier()) {
  ModifierRes = getDerived().TransformExpr(Modifier);
  if (ModifierRes.isInvalid())
    return nullptr;
}
for (Expr *E : C->varlists()) {
  ExprResult Locator = getDerived().TransformExpr(E);
  if (Locator.isInvalid())
    continue;
  Locators.push_back(Locator.get());
}
return getDerived().RebuildOMPAffinityClause(
    C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), C->getEndLoc(),
    ModifierRes.get(), Locators);
10687}

10689template <typename Derived>
10690OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) {
return getDerived().RebuildOMPOrderClause(
    C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(),
    C->getEndLoc(), C->getModifier(), C->getModifierKwLoc());
10694}

10696template <typename Derived>
10697OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *C) {
return getDerived().RebuildOMPBindClause(
    C->getBindKind(), C->getBindKindLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
10701}

10703template <typename Derived>
10704OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause(
  OMPXDynCGroupMemClause *C) {
ExprResult Size = getDerived().TransformExpr(C->getSize());
if (Size.isInvalid())
  return nullptr;
return getDerived().RebuildOMPXDynCGroupMemClause(
    Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10711}

10713//===----------------------------------------------------------------------===//
10714// Expression transformation
10715//===----------------------------------------------------------------------===//
10716template<typename Derived>
10717ExprResult
10718TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *E) {
return TransformExpr(E->getSubExpr());
10720}

10722template <typename Derived>
10723ExprResult TreeTransform<Derived>::TransformSYCLUniqueStableNameExpr(
  SYCLUniqueStableNameExpr *E) {
if (!E->isTypeDependent())
  return E;

TypeSourceInfo *NewT = getDerived().TransformType(E->getTypeSourceInfo());

if (!NewT)
  return ExprError();

if (!getDerived().AlwaysRebuild() && E->getTypeSourceInfo() == NewT)
  return E;

return getDerived().RebuildSYCLUniqueStableNameExpr(
    E->getLocation(), E->getLParenLocation(), E->getRParenLocation(), NewT);
10738}

10740template<typename Derived>
10741ExprResult
10742TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
if (!E->isTypeDependent())
  return E;

return getDerived().RebuildPredefinedExpr(E->getLocation(),
                                          E->getIdentKind());
10748}

10750template<typename Derived>
10751ExprResult
10752TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

ValueDecl *ND
  = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
                                                       E->getDecl()));
if (!ND)
  return ExprError();

NamedDecl *Found = ND;
if (E->getFoundDecl() != E->getDecl()) {
  Found = cast_or_null<NamedDecl>(
      getDerived().TransformDecl(E->getLocation(), E->getFoundDecl()));
  if (!Found)
    return ExprError();
}

DeclarationNameInfo NameInfo = E->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    QualifierLoc == E->getQualifierLoc() &&
    ND == E->getDecl() &&
    Found == E->getFoundDecl() &&
    NameInfo.getName() == E->getDecl()->getDeclName() &&
    !E->hasExplicitTemplateArgs()) {

  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  SemaRef.MarkDeclRefReferenced(E);

  return E;
}

TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
if (E->hasExplicitTemplateArgs()) {
  TemplateArgs = &TransArgs;
  TransArgs.setLAngleLoc(E->getLAngleLoc());
  TransArgs.setRAngleLoc(E->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                              E->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
                                       Found, TemplateArgs);
10809}

10811template<typename Derived>
10812ExprResult
10813TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
return E;
10815}

10817template <typename Derived>
10818ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
  FixedPointLiteral *E) {
return E;
10821}

10823template<typename Derived>
10824ExprResult
10825TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
return E;
10827}

10829template<typename Derived>
10830ExprResult
10831TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
return E;
10833}

10835template<typename Derived>
10836ExprResult
10837TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
return E;
10839}

10841template<typename Derived>
10842ExprResult
10843TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
return E;
10845}

10847template<typename Derived>
10848ExprResult
10849TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
return getDerived().TransformCallExpr(E);
10851}

10853template<typename Derived>
10854ExprResult
10855TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
ExprResult ControllingExpr =
  getDerived().TransformExpr(E->getControllingExpr());
if (ControllingExpr.isInvalid())
  return ExprError();

SmallVector<Expr *, 4> AssocExprs;
SmallVector<TypeSourceInfo *, 4> AssocTypes;
for (const GenericSelectionExpr::Association Assoc : E->associations()) {
  TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
  if (TSI) {
    TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
    if (!AssocType)
      return ExprError();
    AssocTypes.push_back(AssocType);
  } else {
    AssocTypes.push_back(nullptr);
  }

  ExprResult AssocExpr =
      getDerived().TransformExpr(Assoc.getAssociationExpr());
  if (AssocExpr.isInvalid())
    return ExprError();
  AssocExprs.push_back(AssocExpr.get());
}

return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
                                                E->getDefaultLoc(),
                                                E->getRParenLoc(),
                                                ControllingExpr.get(),
                                                AssocTypes,
                                                AssocExprs);
10887}

10889template<typename Derived>
10890ExprResult
10891TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
                                     E->getRParen());
10901}

10903/// The operand of a unary address-of operator has special rules: it's
10904/// allowed to refer to a non-static member of a class even if there's no 'this'
10905/// object available.
10906template<typename Derived>
10907ExprResult
10908TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E))
  return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr);
else
  return getDerived().TransformExpr(E);
10913}

10915template<typename Derived>
10916ExprResult
10917TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
ExprResult SubExpr;
if (E->getOpcode() == UO_AddrOf)
  SubExpr = TransformAddressOfOperand(E->getSubExpr());
else
  SubExpr = TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
                                         E->getOpcode(),
                                         SubExpr.get());
10932}

10934template<typename Derived>
10935ExprResult
10936TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
// Transform the type.
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
if (!Type)
  return ExprError();

// Transform all of the components into components similar to what the
// parser uses.
// FIXME: It would be slightly more efficient in the non-dependent case to
// just map FieldDecls, rather than requiring the rebuilder to look for
// the fields again. However, __builtin_offsetof is rare enough in
// template code that we don't care.
bool ExprChanged = false;
typedef Sema::OffsetOfComponent Component;
SmallVector<Component, 4> Components;
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
  const OffsetOfNode &ON = E->getComponent(I);
  Component Comp;
  Comp.isBrackets = true;
  Comp.LocStart = ON.getSourceRange().getBegin();
  Comp.LocEnd = ON.getSourceRange().getEnd();
  switch (ON.getKind()) {
  case OffsetOfNode::Array: {
    Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
    ExprResult Index = getDerived().TransformExpr(FromIndex);
    if (Index.isInvalid())
      return ExprError();

    ExprChanged = ExprChanged || Index.get() != FromIndex;
    Comp.isBrackets = true;
    Comp.U.E = Index.get();
    break;
  }

  case OffsetOfNode::Field:
  case OffsetOfNode::Identifier:
    Comp.isBrackets = false;
    Comp.U.IdentInfo = ON.getFieldName();
    if (!Comp.U.IdentInfo)
      continue;

    break;

  case OffsetOfNode::Base:
    // Will be recomputed during the rebuild.
    continue;
  }

  Components.push_back(Comp);
}

// If nothing changed, retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeSourceInfo() &&
    !ExprChanged)
  return E;

// Build a new offsetof expression.
return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
                                        Components, E->getRParenLoc());
10996}

10998template<typename Derived>
10999ExprResult
11000TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&(static_cast <bool> ((!E->getSourceExpr() || getDerived
().AlreadyTransformed(E->getType())) && "opaque value expression requires transformation"
) ? void (0) : __assert_fail ("(!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && \"opaque value expression requires transformation\""
, "clang/lib/Sema/TreeTransform.h", 11002, __extension__ __PRETTY_FUNCTION__
))
       "opaque value expression requires transformation")(static_cast <bool> ((!E->getSourceExpr() || getDerived
().AlreadyTransformed(E->getType())) && "opaque value expression requires transformation"
) ? void (0) : __assert_fail ("(!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && \"opaque value expression requires transformation\""
, "clang/lib/Sema/TreeTransform.h", 11002, __extension__ __PRETTY_FUNCTION__
));
return E;
11004}

11006template<typename Derived>
11007ExprResult
11008TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
return E;
11010}

11012template <typename Derived>
11013ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *E) {
llvm::SmallVector<Expr *, 8> Children;
bool Changed = false;
for (Expr *C : E->subExpressions()) {
  ExprResult NewC = getDerived().TransformExpr(C);
  if (NewC.isInvalid())
    return ExprError();
  Children.push_back(NewC.get());

  Changed |= NewC.get() != C;
}
if (!getDerived().AlwaysRebuild() && !Changed)
  return E;
return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(),
                                        Children, E->getType());
11028}

11030template<typename Derived>
11031ExprResult
11032TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
// Rebuild the syntactic form.  The original syntactic form has
// opaque-value expressions in it, so strip those away and rebuild
// the result.  This is a really awful way of doing this, but the
// better solution (rebuilding the semantic expressions and
// rebinding OVEs as necessary) doesn't work; we'd need
// TreeTransform to not strip away implicit conversions.
Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
ExprResult result = getDerived().TransformExpr(newSyntacticForm);
if (result.isInvalid()) return ExprError();

// If that gives us a pseudo-object result back, the pseudo-object
// expression must have been an lvalue-to-rvalue conversion which we
// should reapply.
if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
  result = SemaRef.checkPseudoObjectRValue(result.get());

return result;
11050}

11052template<typename Derived>
11053ExprResult
11054TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
                                              UnaryExprOrTypeTraitExpr *E) {
if (E->isArgumentType()) {
  TypeSourceInfo *OldT = E->getArgumentTypeInfo();

  TypeSourceInfo *NewT = getDerived().TransformType(OldT);
  if (!NewT)
    return ExprError();

  if (!getDerived().AlwaysRebuild() && OldT == NewT)
    return E;

  return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
                                                  E->getKind(),
                                                  E->getSourceRange());
}

// C++0x [expr.sizeof]p1:
//   The operand is either an expression, which is an unevaluated operand
//   [...]
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

// Try to recover if we have something like sizeof(T::X) where X is a type.
// Notably, there must be *exactly* one set of parens if X is a type.
TypeSourceInfo *RecoveryTSI = nullptr;
ExprResult SubExpr;
auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
if (auto *DRE =
        PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
  SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
      PE, DRE, false, &RecoveryTSI);
else
  SubExpr = getDerived().TransformExpr(E->getArgumentExpr());

if (RecoveryTSI) {
  return getDerived().RebuildUnaryExprOrTypeTrait(
      RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
} else if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
  return E;

return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
                                                E->getOperatorLoc(),
                                                E->getKind(),
                                                E->getSourceRange());
11103}

11105template<typename Derived>
11106ExprResult
11107TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();


if (!getDerived().AlwaysRebuild() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildArraySubscriptExpr(
    LHS.get(),
    /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
11125}

11127template <typename Derived>
11128ExprResult
11129TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx());
if (RowIdx.isInvalid())
  return ExprError();

ExprResult ColumnIdx = getDerived().TransformExpr(E->getColumnIdx());
if (ColumnIdx.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
    RowIdx.get() == E->getRowIdx() && ColumnIdx.get() == E->getColumnIdx())
  return E;

return getDerived().RebuildMatrixSubscriptExpr(
    Base.get(), RowIdx.get(), ColumnIdx.get(), E->getRBracketLoc());
11148}

11150template <typename Derived>
11151ExprResult
11152TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ExprResult LowerBound;
if (E->getLowerBound()) {
  LowerBound = getDerived().TransformExpr(E->getLowerBound());
  if (LowerBound.isInvalid())
    return ExprError();
}

ExprResult Length;
if (E->getLength()) {
  Length = getDerived().TransformExpr(E->getLength());
  if (Length.isInvalid())
    return ExprError();
}

ExprResult Stride;
if (Expr *Str = E->getStride()) {
  Stride = getDerived().TransformExpr(Str);
  if (Stride.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
    LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
  return E;

return getDerived().RebuildOMPArraySectionExpr(
    Base.get(), E->getBase()->getEndLoc(), LowerBound.get(),
    E->getColonLocFirst(), E->getColonLocSecond(), Length.get(), Stride.get(),
    E->getRBracketLoc());
11186}

11188template <typename Derived>
11189ExprResult
11190TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

SmallVector<Expr *, 4> Dims;
bool ErrorFound = false;
for (Expr *Dim : E->getDimensions()) {
  ExprResult DimRes = getDerived().TransformExpr(Dim);
  if (DimRes.isInvalid()) {
    ErrorFound = true;
    continue;
  }
  Dims.push_back(DimRes.get());
}

if (ErrorFound)
  return ExprError();
return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(),
                                               E->getRParenLoc(), Dims,
                                               E->getBracketsRanges());
11211}

11213template <typename Derived>
11214ExprResult
11215TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *E) {
unsigned NumIterators = E->numOfIterators();
SmallVector<Sema::OMPIteratorData, 4> Data(NumIterators);

bool ErrorFound = false;
bool NeedToRebuild = getDerived().AlwaysRebuild();
for (unsigned I = 0; I < NumIterators; ++I) {
  auto *D = cast<VarDecl>(E->getIteratorDecl(I));
  Data[I].DeclIdent = D->getIdentifier();
  Data[I].DeclIdentLoc = D->getLocation();
  if (D->getLocation() == D->getBeginLoc()) {
    assert(SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) &&(static_cast <bool> (SemaRef.Context.hasSameType(D->
getType(), SemaRef.Context.IntTy) && "Implicit type must be int."
) ? void (0) : __assert_fail ("SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) && \"Implicit type must be int.\""
, "clang/lib/Sema/TreeTransform.h", 11227, __extension__ __PRETTY_FUNCTION__
))
           "Implicit type must be int.")(static_cast <bool> (SemaRef.Context.hasSameType(D->
getType(), SemaRef.Context.IntTy) && "Implicit type must be int."
) ? void (0) : __assert_fail ("SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) && \"Implicit type must be int.\""
, "clang/lib/Sema/TreeTransform.h", 11227, __extension__ __PRETTY_FUNCTION__
));
  } else {
    TypeSourceInfo *TSI = getDerived().TransformType(D->getTypeSourceInfo());
    QualType DeclTy = getDerived().TransformType(D->getType());
    Data[I].Type = SemaRef.CreateParsedType(DeclTy, TSI);
  }
  OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
  ExprResult Begin = getDerived().TransformExpr(Range.Begin);
  ExprResult End = getDerived().TransformExpr(Range.End);
  ExprResult Step = getDerived().TransformExpr(Range.Step);
  ErrorFound = ErrorFound ||
               !(!D->getTypeSourceInfo() || (Data[I].Type.getAsOpaquePtr() &&
                                             !Data[I].Type.get().isNull())) ||
               Begin.isInvalid() || End.isInvalid() || Step.isInvalid();
  if (ErrorFound)
    continue;
  Data[I].Range.Begin = Begin.get();
  Data[I].Range.End = End.get();
  Data[I].Range.Step = Step.get();
  Data[I].AssignLoc = E->getAssignLoc(I);
  Data[I].ColonLoc = E->getColonLoc(I);
  Data[I].SecColonLoc = E->getSecondColonLoc(I);
  NeedToRebuild =
      NeedToRebuild ||
      (D->getTypeSourceInfo() && Data[I].Type.get().getTypePtrOrNull() !=
                                     D->getType().getTypePtrOrNull()) ||
      Range.Begin != Data[I].Range.Begin || Range.End != Data[I].Range.End ||
      Range.Step != Data[I].Range.Step;
}
if (ErrorFound)
  return ExprError();
if (!NeedToRebuild)
  return E;

ExprResult Res = getDerived().RebuildOMPIteratorExpr(
    E->getIteratorKwLoc(), E->getLParenLoc(), E->getRParenLoc(), Data);
if (!Res.isUsable())
  return Res;
auto *IE = cast<OMPIteratorExpr>(Res.get());
for (unsigned I = 0; I < NumIterators; ++I)
  getDerived().transformedLocalDecl(E->getIteratorDecl(I),
                                    IE->getIteratorDecl(I));
return Res;
11270}

11272template<typename Derived>
11273ExprResult
11274TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
  = ((Expr *)Callee.get())->getSourceRange().getBegin();

Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
if (E->hasStoredFPFeatures()) {
  FPOptionsOverride NewOverrides = E->getFPFeatures();
  getSema().CurFPFeatures =
      NewOverrides.applyOverrides(getSema().getLangOpts());
  getSema().FpPragmaStack.CurrentValue = NewOverrides;
}

return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                    Args,
                                    E->getRParenLoc());
11307}

11309template<typename Derived>
11310ExprResult
11311TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

NestedNameSpecifierLoc QualifierLoc;
if (E->hasQualifier()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());

  if (!QualifierLoc)
    return ExprError();
}
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

ValueDecl *Member
  = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
                                                       E->getMemberDecl()));
if (!Member)
  return ExprError();

NamedDecl *FoundDecl = E->getFoundDecl();
if (FoundDecl == E->getMemberDecl()) {
  FoundDecl = Member;
} else {
  FoundDecl = cast_or_null<NamedDecl>(
                 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
  if (!FoundDecl)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase() &&
    QualifierLoc == E->getQualifierLoc() &&
    Member == E->getMemberDecl() &&
    FoundDecl == E->getFoundDecl() &&
    !E->hasExplicitTemplateArgs()) {

  // Skip for member expression of (this->f), rebuilt thisi->f is needed
  // for Openmp where the field need to be privatizized in the case.
  if (!(isa<CXXThisExpr>(E->getBase()) &&
        getSema().isOpenMPRebuildMemberExpr(cast<ValueDecl>(Member)))) {
    // Mark it referenced in the new context regardless.
    // FIXME: this is a bit instantiation-specific.
    SemaRef.MarkMemberReferenced(E);
    return E;
  }
}

TemplateArgumentListInfo TransArgs;
if (E->hasExplicitTemplateArgs()) {
  TransArgs.setLAngleLoc(E->getLAngleLoc());
  TransArgs.setRAngleLoc(E->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                              E->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

// FIXME: Bogus source location for the operator
SourceLocation FakeOperatorLoc =
    SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());

// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;
DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
if (MemberNameInfo.getName()) {
  MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
  if (!MemberNameInfo.getName())
    return ExprError();
}

return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
                                      E->isArrow(),
                                      QualifierLoc,
                                      TemplateKWLoc,
                                      MemberNameInfo,
                                      Member,
                                      FoundDecl,
                                      (E->hasExplicitTemplateArgs()
                                         ? &TransArgs : nullptr),
                                      FirstQualifierInScope);
11396}

11398template<typename Derived>
11399ExprResult
11400TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

if (E->isCompoundAssignmentOp())
  // FPFeatures has already been established from trailing storage
  return getDerived().RebuildBinaryOperator(
      E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get());
Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
FPOptionsOverride NewOverrides(E->getFPFeatures());
getSema().CurFPFeatures =
    NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;
return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
                                          LHS.get(), RHS.get());
11425}

11427template <typename Derived>
11428ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
  CXXRewrittenBinaryOperator *E) {
CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm();

ExprResult LHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.LHS));
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.RHS));
if (RHS.isInvalid())
  return ExprError();

// Extract the already-resolved callee declarations so that we can restrict
// ourselves to using them as the unqualified lookup results when rebuilding.
UnresolvedSet<2> UnqualLookups;
bool ChangedAnyLookups = false;
Expr *PossibleBinOps[] = {E->getSemanticForm(),
                          const_cast<Expr *>(Decomp.InnerBinOp)};
for (Expr *PossibleBinOp : PossibleBinOps) {
  auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit());
  if (!Op)
    continue;
  auto *Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit());
  if (!Callee || isa<CXXMethodDecl>(Callee->getDecl()))
    continue;

  // Transform the callee in case we built a call to a local extern
  // declaration.
  NamedDecl *Found = cast_or_null<NamedDecl>(getDerived().TransformDecl(
      E->getOperatorLoc(), Callee->getFoundDecl()));
  if (!Found)
    return ExprError();
  if (Found != Callee->getFoundDecl())
    ChangedAnyLookups = true;
  UnqualLookups.addDecl(Found);
}

if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups &&
    LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) {
  // Mark all functions used in the rewrite as referenced. Note that when
  // a < b is rewritten to (a <=> b) < 0, both the <=> and the < might be
  // function calls, and/or there might be a user-defined conversion sequence
  // applied to the operands of the <.
  // FIXME: this is a bit instantiation-specific.
  const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS};
  SemaRef.MarkDeclarationsReferencedInExpr(E, false, StopAt);
  return E;
}

return getDerived().RebuildCXXRewrittenBinaryOperator(
    E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
11479}

11481template<typename Derived>
11482ExprResult
11483TreeTransform<Derived>::TransformCompoundAssignOperator(
                                                    CompoundAssignOperator *E) {
Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
FPOptionsOverride NewOverrides(E->getFPFeatures());
getSema().CurFPFeatures =
    NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;
return getDerived().TransformBinaryOperator(E);
11491}

11493template<typename Derived>
11494ExprResult TreeTransform<Derived>::
11495TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
// Just rebuild the common and RHS expressions and see whether we
// get any changes.

ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
if (commonExpr.isInvalid())
  return ExprError();

ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
if (rhs.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    commonExpr.get() == e->getCommon() &&
    rhs.get() == e->getFalseExpr())
  return e;

return getDerived().RebuildConditionalOperator(commonExpr.get(),
                                               e->getQuestionLoc(),
                                               nullptr,
                                               e->getColonLoc(),
                                               rhs.get());
11517}

11519template<typename Derived>
11520ExprResult
11521TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
  return ExprError();

ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == E->getCond() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildConditionalOperator(Cond.get(),
                                               E->getQuestionLoc(),
                                               LHS.get(),
                                               E->getColonLoc(),
                                               RHS.get());
11545}

11547template<typename Derived>
11548ExprResult
11549TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
// Implicit casts are eliminated during transformation, since they
// will be recomputed by semantic analysis after transformation.
return getDerived().TransformExpr(E->getSubExprAsWritten());
11553}

11555template<typename Derived>
11556ExprResult
11557TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
                                          Type,
                                          E->getRParenLoc(),
                                          SubExpr.get());
11576}

11578template<typename Derived>
11579ExprResult
11580TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
TypeSourceInfo *OldT = E->getTypeSourceInfo();
TypeSourceInfo *NewT = getDerived().TransformType(OldT);
if (!NewT)
  return ExprError();

ExprResult Init = getDerived().TransformExpr(E->getInitializer());
if (Init.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    OldT == NewT &&
    Init.get() == E->getInitializer())
  return SemaRef.MaybeBindToTemporary(E);

// Note: the expression type doesn't necessarily match the
// type-as-written, but that's okay, because it should always be
// derivable from the initializer.

return getDerived().RebuildCompoundLiteralExpr(
    E->getLParenLoc(), NewT,
    /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get());
11602}

11604template<typename Derived>
11605ExprResult
11606TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

// FIXME: Bad source location
SourceLocation FakeOperatorLoc =
    SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc());
return getDerived().RebuildExtVectorElementExpr(
    Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(),
    E->getAccessor());
11621}

11623template<typename Derived>
11624ExprResult
11625TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
if (InitListExpr *Syntactic = E->getSyntacticForm())
  E = Syntactic;

bool InitChanged = false;

EnterExpressionEvaluationContext Context(
    getSema(), EnterExpressionEvaluationContext::InitList);

SmallVector<Expr*, 4> Inits;
if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
                                Inits, &InitChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() && !InitChanged) {
  // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
  // in some cases. We can't reuse it in general, because the syntactic and
  // semantic forms are linked, and we can't know that semantic form will
  // match even if the syntactic form does.
}

return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
                                    E->getRBraceLoc());
11648}

11650template<typename Derived>
11651ExprResult
11652TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
Designation Desig;

// transform the initializer value
ExprResult Init = getDerived().TransformExpr(E->getInit());
if (Init.isInvalid())
  return ExprError();

// transform the designators.
SmallVector<Expr*, 4> ArrayExprs;
bool ExprChanged = false;
for (const DesignatedInitExpr::Designator &D : E->designators()) {
  if (D.isFieldDesignator()) {
    Desig.AddDesignator(Designator::CreateFieldDesignator(
        D.getFieldName(), D.getDotLoc(), D.getFieldLoc()));
    if (D.getFieldDecl()) {
      FieldDecl *Field = cast_or_null<FieldDecl>(
          getDerived().TransformDecl(D.getFieldLoc(), D.getFieldDecl()));
      if (Field != D.getFieldDecl())
        // Rebuild the expression when the transformed FieldDecl is
        // different to the already assigned FieldDecl.
        ExprChanged = true;
    } else {
      // Ensure that the designator expression is rebuilt when there isn't
      // a resolved FieldDecl in the designator as we don't want to assign
      // a FieldDecl to a pattern designator that will be instantiated again.
      ExprChanged = true;
    }
    continue;
  }

  if (D.isArrayDesignator()) {
    ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
    if (Index.isInvalid())
      return ExprError();

    Desig.AddDesignator(
        Designator::CreateArrayDesignator(Index.get(), D.getLBracketLoc()));

    ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
    ArrayExprs.push_back(Index.get());
    continue;
  }

  assert(D.isArrayRangeDesignator() && "New kind of designator?")(static_cast <bool> (D.isArrayRangeDesignator() &&
 "New kind of designator?") ? void (0) : __assert_fail ("D.isArrayRangeDesignator() && \"New kind of designator?\""
, "clang/lib/Sema/TreeTransform.h", 11696, __extension__ __PRETTY_FUNCTION__
));
  ExprResult Start
    = getDerived().TransformExpr(E->getArrayRangeStart(D));
  if (Start.isInvalid())
    return ExprError();

  ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
  if (End.isInvalid())
    return ExprError();

  Desig.AddDesignator(Designator::CreateArrayRangeDesignator(
      Start.get(), End.get(), D.getLBracketLoc(), D.getEllipsisLoc()));

  ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
                End.get() != E->getArrayRangeEnd(D);

  ArrayExprs.push_back(Start.get());
  ArrayExprs.push_back(End.get());
}

if (!getDerived().AlwaysRebuild() &&
    Init.get() == E->getInit() &&
    !ExprChanged)
  return E;

return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
                                              E->getEqualOrColonLoc(),
                                              E->usesGNUSyntax(), Init.get());
11724}

11726// Seems that if TransformInitListExpr() only works on the syntactic form of an
11727// InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
11728template<typename Derived>
11729ExprResult
11730TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
  DesignatedInitUpdateExpr *E) {
llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "::llvm::llvm_unreachable_internal("Unexpected DesignatedInitUpdateExpr in syntactic form of "
 "initializer", "clang/lib/Sema/TreeTransform.h", 11733)
                 "initializer")::llvm::llvm_unreachable_internal("Unexpected DesignatedInitUpdateExpr in syntactic form of "
 "initializer", "clang/lib/Sema/TreeTransform.h", 11733);
return ExprError();
11735}

11737template<typename Derived>
11738ExprResult
11739TreeTransform<Derived>::TransformNoInitExpr(
  NoInitExpr *E) {
llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer")::llvm::llvm_unreachable_internal("Unexpected NoInitExpr in syntactic form of initializer"
, "clang/lib/Sema/TreeTransform.h", 11741);
return ExprError();
11743}

11745template<typename Derived>
11746ExprResult
11747TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer")::llvm::llvm_unreachable_internal("Unexpected ArrayInitLoopExpr outside of initializer"
, "clang/lib/Sema/TreeTransform.h", 11748);
return ExprError();
11750}

11752template<typename Derived>
11753ExprResult
11754TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer")::llvm::llvm_unreachable_internal("Unexpected ArrayInitIndexExpr outside of initializer"
, "clang/lib/Sema/TreeTransform.h", 11755);
return ExprError();
11757}

11759template<typename Derived>
11760ExprResult
11761TreeTransform<Derived>::TransformImplicitValueInitExpr(
                                                   ImplicitValueInitExpr *E) {
TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName());

// FIXME: Will we ever have proper type location here? Will we actually
// need to transform the type?
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getType())
  return E;

return getDerived().RebuildImplicitValueInitExpr(T);
11776}

11778template<typename Derived>
11779ExprResult
11780TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
if (!TInfo)
  return ExprError();

ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    TInfo == E->getWrittenTypeInfo() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
                                     TInfo, E->getRParenLoc());
11796}

11798template<typename Derived>
11799ExprResult
11800TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 4> Inits;
if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
                   &ArgumentChanged))
  return ExprError();

return getDerived().RebuildParenListExpr(E->getLParenLoc(),
                                         Inits,
                                         E->getRParenLoc());
11810}

11812/// Transform an address-of-label expression.
11813///
11814/// By default, the transformation of an address-of-label expression always
11815/// rebuilds the expression, so that the label identifier can be resolved to
11816/// the corresponding label statement by semantic analysis.
11817template<typename Derived>
11818ExprResult
11819TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
                                      E->getLabel());
if (!LD)
  return ExprError();

return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
                                         cast<LabelDecl>(LD));
11827}

11829template<typename Derived>
11830ExprResult
11831TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
SemaRef.ActOnStartStmtExpr();
StmtResult SubStmt
  = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
if (SubStmt.isInvalid()) {
  SemaRef.ActOnStmtExprError();
  return ExprError();
}

unsigned OldDepth = E->getTemplateDepth();
unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);

if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
    SubStmt.get() == E->getSubStmt()) {
  // Calling this an 'error' is unintuitive, but it does the right thing.
  SemaRef.ActOnStmtExprError();
  return SemaRef.MaybeBindToTemporary(E);
}

return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(),
                                    E->getRParenLoc(), NewDepth);
11852}

11854template<typename Derived>
11855ExprResult
11856TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
  return ExprError();

ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == E->getCond() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
                                      Cond.get(), LHS.get(), RHS.get(),
                                      E->getRParenLoc());
11878}

11880template<typename Derived>
11881ExprResult
11882TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
return E;
11884}

11886template<typename Derived>
11887ExprResult
11888TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
switch (E->getOperator()) {
case OO_New:
case OO_Delete:
case OO_Array_New:
case OO_Array_Delete:
  llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr")::llvm::llvm_unreachable_internal("new and delete operators cannot use CXXOperatorCallExpr"
, "clang/lib/Sema/TreeTransform.h", 11894);

case OO_Subscript:
case OO_Call: {
  // This is a call to an object's operator().
  assert(E->getNumArgs() >= 1 && "Object call is missing arguments")(static_cast <bool> (E->getNumArgs() >= 1 &&
 "Object call is missing arguments") ? void (0) : __assert_fail
 ("E->getNumArgs() >= 1 && \"Object call is missing arguments\""
, "clang/lib/Sema/TreeTransform.h", 11899, __extension__ __PRETTY_FUNCTION__
));

  // Transform the object itself.
  ExprResult Object = getDerived().TransformExpr(E->getArg(0));
  if (Object.isInvalid())
    return ExprError();

  // FIXME: Poor location information
  SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
      static_cast<Expr *>(Object.get())->getEndLoc());

  // Transform the call arguments.
  SmallVector<Expr*, 8> Args;
  if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
                                  Args))
    return ExprError();

  if (E->getOperator() == OO_Subscript)
    return getDerived().RebuildCxxSubscriptExpr(Object.get(), FakeLParenLoc,
                                                Args, E->getEndLoc());

  return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args,
                                      E->getEndLoc());
}

11924#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)  \
case OO_##Name:                                                              \
  break;

11928#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
11929#include "clang/Basic/OperatorKinds.def"

case OO_Conditional:
  llvm_unreachable("conditional operator is not actually overloadable")::llvm::llvm_unreachable_internal("conditional operator is not actually overloadable"
, "clang/lib/Sema/TreeTransform.h", 11932);

case OO_None:
case NUM_OVERLOADED_OPERATORS:
  llvm_unreachable("not an overloaded operator?")::llvm::llvm_unreachable_internal("not an overloaded operator?"
, "clang/lib/Sema/TreeTransform.h", 11936);
}

ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

ExprResult First;
if (E->getOperator() == OO_Amp)
  First = getDerived().TransformAddressOfOperand(E->getArg(0));
else
  First = getDerived().TransformExpr(E->getArg(0));
if (First.isInvalid())
  return ExprError();

ExprResult Second;
if (E->getNumArgs() == 2) {
  Second = getDerived().TransformExpr(E->getArg(1));
  if (Second.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    First.get() == E->getArg(0) &&
    (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
  return SemaRef.MaybeBindToTemporary(E);

Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
FPOptionsOverride NewOverrides(E->getFPFeatures());
getSema().CurFPFeatures =
    NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;

return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
                                               E->getOperatorLoc(),
                                               Callee.get(),
                                               First.get(),
                                               Second.get());
11975}

11977template<typename Derived>
11978ExprResult
11979TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
return getDerived().TransformCallExpr(E);
11981}

11983template <typename Derived>
11984ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
bool NeedRebuildFunc = E->getIdentKind() == SourceLocExpr::Function &&
                       getSema().CurContext != E->getParentContext();

if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
  return E;

return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getType(),
                                         E->getBeginLoc(), E->getEndLoc(),
                                         getSema().CurContext);
11994}

11996template<typename Derived>
11997ExprResult
11998TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

// Transform exec config.
ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
if (EC.isInvalid())
  return ExprError();

// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
  = ((Expr *)Callee.get())->getSourceRange().getBegin();
return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                    Args,
                                    E->getRParenLoc(), EC.get());
12027}

12029template<typename Derived>
12030ExprResult
12031TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;
return getDerived().RebuildCXXNamedCastExpr(
    E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
    Type, E->getAngleBrackets().getEnd(),
    // FIXME. this should be '(' location
    E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
12050}

12052template<typename Derived>
12053ExprResult
12054TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
TypeSourceInfo *TSI =
    getDerived().TransformType(BCE->getTypeInfoAsWritten());
if (!TSI)
  return ExprError();

ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
if (Sub.isInvalid())
  return ExprError();

return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
                                              Sub.get(), BCE->getEndLoc());
12066}

12068template<typename Derived>
12069ExprResult
12070TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12072}

12074template<typename Derived>
12075ExprResult
12076TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12078}

12080template<typename Derived>
12081ExprResult
12082TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
                                                    CXXReinterpretCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12085}

12087template<typename Derived>
12088ExprResult
12089TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12091}

12093template<typename Derived>
12094ExprResult
12095TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12097}

12099template<typename Derived>
12100ExprResult
12101TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
                                                   CXXFunctionalCastExpr *E) {
TypeSourceInfo *Type =
    getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCXXFunctionalCastExpr(Type,
                                                 E->getLParenLoc(),
                                                 SubExpr.get(),
                                                 E->getRParenLoc(),
                                                 E->isListInitialization());
12123}

12125template<typename Derived>
12126ExprResult
12127TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
if (E->isTypeOperand()) {
  TypeSourceInfo *TInfo
    = getDerived().TransformType(E->getTypeOperandSourceInfo());
  if (!TInfo)
    return ExprError();

  if (!getDerived().AlwaysRebuild() &&
      TInfo == E->getTypeOperandSourceInfo())
    return E;

  return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
                                           TInfo, E->getEndLoc());
}

// Typeid's operand is an unevaluated context, unless it's a polymorphic
// type.  We must not unilaterally enter unevaluated context here, as then
// semantic processing can re-transform an already transformed operand.
Expr *Op = E->getExprOperand();
auto EvalCtx = Sema::ExpressionEvaluationContext::Unevaluated;
if (E->isGLValue())
  if (auto *RecordT = Op->getType()->getAs<RecordType>())
    if (cast<CXXRecordDecl>(RecordT->getDecl())->isPolymorphic())
      EvalCtx = SemaRef.ExprEvalContexts.back().Context;

EnterExpressionEvaluationContext Unevaluated(SemaRef, EvalCtx,
                                             Sema::ReuseLambdaContextDecl);

ExprResult SubExpr = getDerived().TransformExpr(Op);
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getExprOperand())
  return E;

return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
                                         SubExpr.get(), E->getEndLoc());
12165}

12167template<typename Derived>
12168ExprResult
12169TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
if (E->isTypeOperand()) {
  TypeSourceInfo *TInfo
    = getDerived().TransformType(E->getTypeOperandSourceInfo());
  if (!TInfo)
    return ExprError();

  if (!getDerived().AlwaysRebuild() &&
      TInfo == E->getTypeOperandSourceInfo())
    return E;

  return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
                                           TInfo, E->getEndLoc());
}

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);

ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getExprOperand())
  return E;

return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
                                         SubExpr.get(), E->getEndLoc());
12197}

12199template<typename Derived>
12200ExprResult
12201TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
return E;
12203}

12205template<typename Derived>
12206ExprResult
12207TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
                                                   CXXNullPtrLiteralExpr *E) {
return E;
12210}

12212template<typename Derived>
12213ExprResult
12214TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
QualType T = getSema().getCurrentThisType();

if (!getDerived().AlwaysRebuild() && T == E->getType()) {
  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  getSema().MarkThisReferenced(E);
  return E;
}

return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit());
12225}

12227template<typename Derived>
12228ExprResult
12229TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
                                        E->isThrownVariableInScope());
12240}

12242template<typename Derived>
12243ExprResult
12244TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
if (!Param)
  return ExprError();

ExprResult InitRes;
if (E->hasRewrittenInit()) {
  InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
  if (InitRes.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
    E->getUsedContext() == SemaRef.CurContext &&
    InitRes.get() == E->getRewrittenExpr())
  return E;

return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param,
                                             InitRes.get());
12264}

12266template<typename Derived>
12267ExprResult
12268TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
FieldDecl *Field = cast_or_null<FieldDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
if (!Field)
  return ExprError();

if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
    E->getUsedContext() == SemaRef.CurContext)
  return E;

return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
12279}

12281template<typename Derived>
12282ExprResult
12283TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
                                                  CXXScalarValueInitExpr *E) {
TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
if (!T)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo())
  return E;

return getDerived().RebuildCXXScalarValueInitExpr(T,
                                        /*FIXME:*/T->getTypeLoc().getEndLoc(),
                                                  E->getRParenLoc());
12296}

12298template<typename Derived>
12299ExprResult
12300TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
// Transform the type that we're allocating
TypeSourceInfo *AllocTypeInfo =
    getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
if (!AllocTypeInfo)
  return ExprError();

// Transform the size of the array we're allocating (if any).
std::optional<Expr *> ArraySize;
if (E->isArray()) {
  ExprResult NewArraySize;
  if (std::optional<Expr *> OldArraySize = E->getArraySize()) {
    NewArraySize = getDerived().TransformExpr(*OldArraySize);
    if (NewArraySize.isInvalid())
      return ExprError();
  }
  ArraySize = NewArraySize.get();
}

// Transform the placement arguments (if any).
bool ArgumentChanged = false;
SmallVector<Expr*, 8> PlacementArgs;
if (getDerived().TransformExprs(E->getPlacementArgs(),
                                E->getNumPlacementArgs(), true,
                                PlacementArgs, &ArgumentChanged))
  return ExprError();

// Transform the initializer (if any).
Expr *OldInit = E->getInitializer();
ExprResult NewInit;
if (OldInit)
  NewInit = getDerived().TransformInitializer(OldInit, true);
if (NewInit.isInvalid())
  return ExprError();

// Transform new operator and delete operator.
FunctionDecl *OperatorNew = nullptr;
if (E->getOperatorNew()) {
  OperatorNew = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
  if (!OperatorNew)
    return ExprError();
}

FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
  OperatorDelete = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
  if (!OperatorDelete)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
    ArraySize == E->getArraySize() &&
    NewInit.get() == OldInit &&
    OperatorNew == E->getOperatorNew() &&
    OperatorDelete == E->getOperatorDelete() &&
    !ArgumentChanged) {
  // Mark any declarations we need as referenced.
  // FIXME: instantiation-specific.
  if (OperatorNew)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew);
  if (OperatorDelete)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);

  if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
    QualType ElementType
      = SemaRef.Context.getBaseElementType(E->getAllocatedType());
    if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
      if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
        SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor);
      }
    }
  }

  return E;
}

QualType AllocType = AllocTypeInfo->getType();
if (!ArraySize) {
  // If no array size was specified, but the new expression was
  // instantiated with an array type (e.g., "new T" where T is
  // instantiated with "int[4]"), extract the outer bound from the
  // array type as our array size. We do this with constant and
  // dependently-sized array types.
  const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
  if (!ArrayT) {
    // Do nothing
  } else if (const ConstantArrayType *ConsArrayT
                                   = dyn_cast<ConstantArrayType>(ArrayT)) {
    ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
                                       SemaRef.Context.getSizeType(),
                                       /*FIXME:*/ E->getBeginLoc());
    AllocType = ConsArrayT->getElementType();
  } else if (const DependentSizedArrayType *DepArrayT
                            = dyn_cast<DependentSizedArrayType>(ArrayT)) {
    if (DepArrayT->getSizeExpr()) {
      ArraySize = DepArrayT->getSizeExpr();
      AllocType = DepArrayT->getElementType();
    }
  }
}

return getDerived().RebuildCXXNewExpr(
    E->getBeginLoc(), E->isGlobalNew(),
    /*FIXME:*/ E->getBeginLoc(), PlacementArgs,
    /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
    AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
12410}

12412template<typename Derived>
12413ExprResult
12414TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
ExprResult Operand = getDerived().TransformExpr(E->getArgument());
if (Operand.isInvalid())
  return ExprError();

// Transform the delete operator, if known.
FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
  OperatorDelete = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
  if (!OperatorDelete)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Operand.get() == E->getArgument() &&
    OperatorDelete == E->getOperatorDelete()) {
  // Mark any declarations we need as referenced.
  // FIXME: instantiation-specific.
  if (OperatorDelete)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);

  if (!E->getArgument()->isTypeDependent()) {
    QualType Destroyed = SemaRef.Context.getBaseElementType(
                                                       E->getDestroyedType());
    if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
      SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
                                     SemaRef.LookupDestructor(Record));
    }
  }

  return E;
}

return getDerived().RebuildCXXDeleteExpr(
    E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get());
12451}

12453template<typename Derived>
12454ExprResult
12455TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
                                                   CXXPseudoDestructorExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ParsedType ObjectTypePtr;
bool MayBePseudoDestructor = false;
Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
                                            E->getOperatorLoc(),
                                      E->isArrow()? tok::arrow : tok::period,
                                            ObjectTypePtr,
                                            MayBePseudoDestructor);
if (Base.isInvalid())
  return ExprError();

QualType ObjectType = ObjectTypePtr.get();
NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
  if (!QualifierLoc)
    return ExprError();
}
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

PseudoDestructorTypeStorage Destroyed;
if (E->getDestroyedTypeInfo()) {
  TypeSourceInfo *DestroyedTypeInfo
    = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
                                              ObjectType, nullptr, SS);
  if (!DestroyedTypeInfo)
    return ExprError();
  Destroyed = DestroyedTypeInfo;
} else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
  // We aren't likely to be able to resolve the identifier down to a type
  // now anyway, so just retain the identifier.
  Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
                                          E->getDestroyedTypeLoc());
} else {
  // Look for a destructor known with the given name.
  ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
                                            *E->getDestroyedTypeIdentifier(),
                                              E->getDestroyedTypeLoc(),
                                              /*Scope=*/nullptr,
                                              SS, ObjectTypePtr,
                                              false);
  if (!T)
    return ExprError();

  Destroyed
    = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
                                               E->getDestroyedTypeLoc());
}

TypeSourceInfo *ScopeTypeInfo = nullptr;
if (E->getScopeTypeInfo()) {
  CXXScopeSpec EmptySS;
  ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
                    E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
  if (!ScopeTypeInfo)
    return ExprError();
}

return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
                                                   E->getOperatorLoc(),
                                                   E->isArrow(),
                                                   SS,
                                                   ScopeTypeInfo,
                                                   E->getColonColonLoc(),
                                                   E->getTildeLoc(),
                                                   Destroyed);
12528}

12530template <typename Derived>
12531bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old,
                                                      bool RequiresADL,
                                                      LookupResult &R) {
// Transform all the decls.
bool AllEmptyPacks = true;
for (auto *OldD : Old->decls()) {
  Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
  if (!InstD) {
    // Silently ignore these if a UsingShadowDecl instantiated to nothing.
    // This can happen because of dependent hiding.
    if (isa<UsingShadowDecl>(OldD))
      continue;
    else {
      R.clear();
      return true;
    }
  }

  // Expand using pack declarations.
  NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
  ArrayRef<NamedDecl*> Decls = SingleDecl;
  if (auto *UPD = dyn_cast<UsingPackDecl>(InstD))
    Decls = UPD->expansions();

  // Expand using declarations.
  for (auto *D : Decls) {
    if (auto *UD = dyn_cast<UsingDecl>(D)) {
      for (auto *SD : UD->shadows())
        R.addDecl(SD);
    } else {
      R.addDecl(D);
    }
  }

  AllEmptyPacks &= Decls.empty();
};

// C++ [temp.res]/8.4.2:
//   The program is ill-formed, no diagnostic required, if [...] lookup for
//   a name in the template definition found a using-declaration, but the
//   lookup in the corresponding scope in the instantiation odoes not find
//   any declarations because the using-declaration was a pack expansion and
//   the corresponding pack is empty
if (AllEmptyPacks && !RequiresADL) {
  getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
      << isa<UnresolvedMemberExpr>(Old) << Old->getName();
  return true;
}

// Resolve a kind, but don't do any further analysis.  If it's
// ambiguous, the callee needs to deal with it.
R.resolveKind();
return false;
12584}

12586template<typename Derived>
12587ExprResult
12588TreeTransform<Derived>::TransformUnresolvedLookupExpr(
                                                UnresolvedLookupExpr *Old) {
LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
               Sema::LookupOrdinaryName);

// Transform the declaration set.
if (TransformOverloadExprDecls(Old, Old->requiresADL(), R))
  return ExprError();

// Rebuild the nested-name qualifier, if present.
CXXScopeSpec SS;
if (Old->getQualifierLoc()) {
  NestedNameSpecifierLoc QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();

  SS.Adopt(QualifierLoc);
}

if (Old->getNamingClass()) {
  CXXRecordDecl *NamingClass
    = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
                                                          Old->getNameLoc(),
                                                      Old->getNamingClass()));
  if (!NamingClass) {
    R.clear();
    return ExprError();
  }

  R.setNamingClass(NamingClass);
}

SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();

// If we have neither explicit template arguments, nor the template keyword,
// it's a normal declaration name or member reference.
if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
  NamedDecl *D = R.getAsSingle<NamedDecl>();
  // In a C++11 unevaluated context, an UnresolvedLookupExpr might refer to an
  // instance member. In other contexts, BuildPossibleImplicitMemberExpr will
  // give a good diagnostic.
  if (D && D->isCXXInstanceMember()) {
    return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
                                                   /*TemplateArgs=*/nullptr,
                                                   /*Scope=*/nullptr);
  }

  return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
}

// If we have template arguments, rebuild them, then rebuild the
// templateid expression.
TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
if (Old->hasExplicitTemplateArgs() &&
    getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                            Old->getNumTemplateArgs(),
                                            TransArgs)) {
  R.clear();
  return ExprError();
}

return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
                                          Old->requiresADL(), &TransArgs);
12652}

12654template<typename Derived>
12655ExprResult
12656TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
bool ArgChanged = false;
SmallVector<TypeSourceInfo *, 4> Args;
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
  TypeSourceInfo *From = E->getArg(I);
  TypeLoc FromTL = From->getTypeLoc();
  if (!FromTL.getAs<PackExpansionTypeLoc>()) {
    TypeLocBuilder TLB;
    TLB.reserve(FromTL.getFullDataSize());
    QualType To = getDerived().TransformType(TLB, FromTL);
    if (To.isNull())
      return ExprError();

    if (To == From->getType())
      Args.push_back(From);
    else {
      Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
      ArgChanged = true;
    }
    continue;
  }

  ArgChanged = true;

  // We have a pack expansion. Instantiate it.
  PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
  TypeLoc PatternTL = ExpansionTL.getPatternLoc();
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  std::optional<unsigned> OrigNumExpansions =
      ExpansionTL.getTypePtr()->getNumExpansions();
  std::optional<unsigned> NumExpansions = OrigNumExpansions;
  if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                           PatternTL.getSourceRange(),
                                           Unexpanded,
                                           Expand, RetainExpansion,
                                           NumExpansions))
    return ExprError();

  if (!Expand) {
    // The transform has determined that we should perform a simple
    // transformation on the pack expansion, producing another pack
    // expansion.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

    TypeLocBuilder TLB;
    TLB.reserve(From->getTypeLoc().getFullDataSize());

    QualType To = getDerived().TransformType(TLB, PatternTL);
    if (To.isNull())
      return ExprError();

    To = getDerived().RebuildPackExpansionType(To,
                                               PatternTL.getSourceRange(),
                                               ExpansionTL.getEllipsisLoc(),
                                               NumExpansions);
    if (To.isNull())
      return ExprError();

    PackExpansionTypeLoc ToExpansionTL
      = TLB.push<PackExpansionTypeLoc>(To);
    ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
    Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
    continue;
  }

  // Expand the pack expansion by substituting for each argument in the
  // pack(s).
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
    TypeLocBuilder TLB;
    TLB.reserve(PatternTL.getFullDataSize());
    QualType To = getDerived().TransformType(TLB, PatternTL);
    if (To.isNull())
      return ExprError();

    if (To->containsUnexpandedParameterPack()) {
      To = getDerived().RebuildPackExpansionType(To,
                                                 PatternTL.getSourceRange(),
                                                 ExpansionTL.getEllipsisLoc(),
                                                 NumExpansions);
      if (To.isNull())
        return ExprError();

      PackExpansionTypeLoc ToExpansionTL
        = TLB.push<PackExpansionTypeLoc>(To);
      ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
    }

    Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
  }

  if (!RetainExpansion)
    continue;

  // If we're supposed to retain a pack expansion, do so by temporarily
  // forgetting the partially-substituted parameter pack.
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  TypeLocBuilder TLB;
  TLB.reserve(From->getTypeLoc().getFullDataSize());

  QualType To = getDerived().TransformType(TLB, PatternTL);
  if (To.isNull())
    return ExprError();

  To = getDerived().RebuildPackExpansionType(To,
                                             PatternTL.getSourceRange(),
                                             ExpansionTL.getEllipsisLoc(),
                                             NumExpansions);
  if (To.isNull())
    return ExprError();

  PackExpansionTypeLoc ToExpansionTL
    = TLB.push<PackExpansionTypeLoc>(To);
  ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
  Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
}

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return E;

return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
                                     E->getEndLoc());
12785}

12787template<typename Derived>
12788ExprResult
12789TreeTransform<Derived>::TransformConceptSpecializationExpr(
                                               ConceptSpecializationExpr *E) {
const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                            Old->NumTemplateArgs, TransArgs))
  return ExprError();

return getDerived().RebuildConceptSpecializationExpr(
    E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
    E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
    &TransArgs);
12801}

12803template<typename Derived>
12804ExprResult
12805TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
SmallVector<ParmVarDecl*, 4> TransParams;
SmallVector<QualType, 4> TransParamTypes;
Sema::ExtParameterInfoBuilder ExtParamInfos;

// C++2a [expr.prim.req]p2
// Expressions appearing within a requirement-body are unevaluated operands.
EnterExpressionEvaluationContext Ctx(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(
    getSema().Context, getSema().CurContext,
    E->getBody()->getBeginLoc());

Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false);

ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams(
    E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body,
    E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);

for (ParmVarDecl *Param : TransParams)
  if (Param)
    Param->setDeclContext(Body);

// On failure to transform, TransformRequiresTypeParams returns an expression
// in the event that the transformation of the type params failed in some way.
// It is expected that this will result in a 'not satisfied' Requires clause
// when instantiating.
if (!TypeParamResult.isUnset())
  return TypeParamResult;

SmallVector<concepts::Requirement *, 4> TransReqs;
if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
                                                   TransReqs))
  return ExprError();

for (concepts::Requirement *Req : TransReqs) {
  if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
    if (ER->getReturnTypeRequirement().isTypeConstraint()) {
      ER->getReturnTypeRequirement()
              .getTypeConstraintTemplateParameterList()->getParam(0)
              ->setDeclContext(Body);
    }
  }
}

return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
                                        TransParams, TransReqs,
                                        E->getRBraceLoc());
12855}

12857template<typename Derived>
12858bool TreeTransform<Derived>::TransformRequiresExprRequirements(
  ArrayRef<concepts::Requirement *> Reqs,
  SmallVectorImpl<concepts::Requirement *> &Transformed) {
for (concepts::Requirement *Req : Reqs) {
  concepts::Requirement *TransReq = nullptr;
  if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
    TransReq = getDerived().TransformTypeRequirement(TypeReq);
  else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
    TransReq = getDerived().TransformExprRequirement(ExprReq);
  else
    TransReq = getDerived().TransformNestedRequirement(
                   cast<concepts::NestedRequirement>(Req));
  if (!TransReq)
    return true;
  Transformed.push_back(TransReq);
}
return false;
12875}

12877template<typename Derived>
12878concepts::TypeRequirement *
12879TreeTransform<Derived>::TransformTypeRequirement(
  concepts::TypeRequirement *Req) {
if (Req->isSubstitutionFailure()) {
  if (getDerived().AlwaysRebuild())
    return getDerived().RebuildTypeRequirement(
            Req->getSubstitutionDiagnostic());
  return Req;
}
TypeSourceInfo *TransType = getDerived().TransformType(Req->getType());
if (!TransType)
  return nullptr;
return getDerived().RebuildTypeRequirement(TransType);
12891}

12893template<typename Derived>
12894concepts::ExprRequirement *
12895TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) {
llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr;
if (Req->isExprSubstitutionFailure())
  TransExpr = Req->getExprSubstitutionDiagnostic();
else {
  ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr());
  if (TransExprRes.isUsable() && TransExprRes.get()->hasPlaceholderType())
    TransExprRes = SemaRef.CheckPlaceholderExpr(TransExprRes.get());
  if (TransExprRes.isInvalid())
    return nullptr;
  TransExpr = TransExprRes.get();
}

std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
const auto &RetReq = Req->getReturnTypeRequirement();
if (RetReq.isEmpty())
  TransRetReq.emplace();
else if (RetReq.isSubstitutionFailure())
  TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
else if (RetReq.isTypeConstraint()) {
  TemplateParameterList *OrigTPL =
      RetReq.getTypeConstraintTemplateParameterList();
  TemplateParameterList *TPL =
      getDerived().TransformTemplateParameterList(OrigTPL);
  if (!TPL)
    return nullptr;
  TransRetReq.emplace(TPL);
}
assert(TransRetReq && "All code paths leading here must set TransRetReq")(static_cast <bool> (TransRetReq && "All code paths leading here must set TransRetReq"
) ? void (0) : __assert_fail ("TransRetReq && \"All code paths leading here must set TransRetReq\""
, "clang/lib/Sema/TreeTransform.h", 12923, __extension__ __PRETTY_FUNCTION__
));
if (Expr *E = TransExpr.dyn_cast<Expr *>())
  return getDerived().RebuildExprRequirement(E, Req->isSimple(),
                                             Req->getNoexceptLoc(),
                                             std::move(*TransRetReq));
return getDerived().RebuildExprRequirement(
    TransExpr.get<concepts::Requirement::SubstitutionDiagnostic *>(),
    Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
12931}

12933template<typename Derived>
12934concepts::NestedRequirement *
12935TreeTransform<Derived>::TransformNestedRequirement(
  concepts::NestedRequirement *Req) {
if (Req->hasInvalidConstraint()) {
  if (getDerived().AlwaysRebuild())
    return getDerived().RebuildNestedRequirement(
        Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction());
  return Req;
}
ExprResult TransConstraint =
    getDerived().TransformExpr(Req->getConstraintExpr());
if (TransConstraint.isInvalid())
  return nullptr;
return getDerived().RebuildNestedRequirement(TransConstraint.get());
12948}

12950template<typename Derived>
12951ExprResult
12952TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
if (!T)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getQueriedTypeSourceInfo())
  return E;

ExprResult SubExpr;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
  SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
  if (SubExpr.isInvalid())
    return ExprError();

  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
    return E;
}

return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T,
                                          SubExpr.get(), E->getEndLoc());
12975}

12977template<typename Derived>
12978ExprResult
12979TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
ExprResult SubExpr;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
  SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
  if (SubExpr.isInvalid())
    return ExprError();

  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
    return E;
}

return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(),
                                           SubExpr.get(), E->getEndLoc());
12994}

12996template <typename Derived>
12997ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
  ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
  TypeSourceInfo **RecoveryTSI) {
ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
    DRE, AddrTaken, RecoveryTSI);

// Propagate both errors and recovered types, which return ExprEmpty.
if (!NewDRE.isUsable())
  return NewDRE;

// We got an expr, wrap it up in parens.
if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
  return PE;
return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
                                     PE->getRParen());
13012}

13014template <typename Derived>
13015ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
  DependentScopeDeclRefExpr *E) {
return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
                                          nullptr);
13019}

13021template <typename Derived>
13022ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
  DependentScopeDeclRefExpr *E, bool IsAddressOfOperand,
  TypeSourceInfo **RecoveryTSI) {
assert(E->getQualifierLoc())(static_cast <bool> (E->getQualifierLoc()) ? void (0
) : __assert_fail ("E->getQualifierLoc()", "clang/lib/Sema/TreeTransform.h"
, 13025, __extension__ __PRETTY_FUNCTION__));
NestedNameSpecifierLoc QualifierLoc =
    getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
if (!QualifierLoc)
  return ExprError();
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.

DeclarationNameInfo NameInfo =
    getDerived().TransformDeclarationNameInfo(E->getNameInfo());
if (!NameInfo.getName())
  return ExprError();

if (!E->hasExplicitTemplateArgs()) {
  if (!getDerived().AlwaysRebuild() && QualifierLoc == E->getQualifierLoc() &&
      // Note: it is sufficient to compare the Name component of NameInfo:
      // if name has not changed, DNLoc has not changed either.
      NameInfo.getName() == E->getDeclName())
    return E;

  return getDerived().RebuildDependentScopeDeclRefExpr(
      QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
      IsAddressOfOperand, RecoveryTSI);
}

TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(
        E->getTemplateArgs(), E->getNumTemplateArgs(), TransArgs))
  return ExprError();

return getDerived().RebuildDependentScopeDeclRefExpr(
    QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
    RecoveryTSI);
13061}

13063template<typename Derived>
13064ExprResult
13065TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
// CXXConstructExprs other than for list-initialization and
// CXXTemporaryObjectExpr are always implicit, so when we have
// a 1-argument construction we just transform that argument.
if (getDerived().AllowSkippingCXXConstructExpr() &&
    ((E->getNumArgs() == 1 ||
      (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
     (!getDerived().DropCallArgument(E->getArg(0))) &&
     !E->isListInitialization()))
  return getDerived().TransformInitializer(E->getArg(0),
                                           /*DirectInit*/ false);

TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());

QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                  &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getType() &&
    Constructor == E->getConstructor() &&
    !ArgumentChanged) {
  // Mark the constructor as referenced.
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return E;
}

return getDerived().RebuildCXXConstructExpr(
    T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
    E->hadMultipleCandidates(), E->isListInitialization(),
    E->isStdInitListInitialization(), E->requiresZeroInitialization(),
    E->getConstructionKind(), E->getParenOrBraceRange());
13114}

13116template<typename Derived>
13117ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
  CXXInheritedCtorInitExpr *E) {
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getType() &&
    Constructor == E->getConstructor()) {
  // Mark the constructor as referenced.
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return E;
}

return getDerived().RebuildCXXInheritedCtorInitExpr(
    T, E->getLocation(), Constructor,
    E->constructsVBase(), E->inheritedFromVBase());
13140}

13142/// Transform a C++ temporary-binding expression.
13143///
13144/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
13145/// transform the subexpression and return that.
13146template<typename Derived>
13147ExprResult
13148TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
if (auto *Dtor = E->getTemporary()->getDestructor())
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
                                 const_cast<CXXDestructorDecl *>(Dtor));
return getDerived().TransformExpr(E->getSubExpr());
13153}

13155/// Transform a C++ expression that contains cleanups that should
13156/// be run after the expression is evaluated.
13157///
13158/// Since ExprWithCleanups nodes are implicitly generated, we
13159/// just transform the subexpression and return that.
13160template<typename Derived>
13161ExprResult
13162TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
return getDerived().TransformExpr(E->getSubExpr());
13164}

13166template<typename Derived>
13167ExprResult
13168TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
                                                  CXXTemporaryObjectExpr *E) {
TypeSourceInfo *T =
    getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                     &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo() &&
    Constructor == E->getConstructor() &&
    !ArgumentChanged) {
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return SemaRef.MaybeBindToTemporary(E);
}

// FIXME: We should just pass E->isListInitialization(), but we're not
// prepared to handle list-initialization without a child InitListExpr.
SourceLocation LParenLoc = T->getTypeLoc().getEndLoc();
return getDerived().RebuildCXXTemporaryObjectExpr(
    T, LParenLoc, Args, E->getEndLoc(),
    /*ListInitialization=*/LParenLoc.isInvalid());
13207}

13209template<typename Derived>
13210ExprResult
13211TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
// Transform any init-capture expressions before entering the scope of the
// lambda body, because they are not semantically within that scope.
typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
struct TransformedInitCapture {
  // The location of the ... if the result is retaining a pack expansion.
  SourceLocation EllipsisLoc;
  // Zero or more expansions of the init-capture.
  SmallVector<InitCaptureInfoTy, 4> Expansions;
};
SmallVector<TransformedInitCapture, 4> InitCaptures;
InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                  CEnd = E->capture_end();
     C != CEnd; ++C) {
  if (!E->isInitCapture(C))
    continue;

  TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
  auto *OldVD = cast<VarDecl>(C->getCapturedVar());

  auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
                              std::optional<unsigned> NumExpansions) {
    ExprResult NewExprInitResult = getDerived().TransformInitializer(
        OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);

    if (NewExprInitResult.isInvalid()) {
      Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType()));
      return;
    }
    Expr *NewExprInit = NewExprInitResult.get();

    QualType NewInitCaptureType =
        getSema().buildLambdaInitCaptureInitialization(
            C->getLocation(), C->getCaptureKind() == LCK_ByRef,
            EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
            cast<VarDecl>(C->getCapturedVar())->getInitStyle() !=
                VarDecl::CInit,
            NewExprInit);
    Result.Expansions.push_back(
        InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
  };

  // If this is an init-capture pack, consider expanding the pack now.
  if (OldVD->isParameterPack()) {
    PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
                                           ->getTypeLoc()
                                           .castAs<PackExpansionTypeLoc>();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded);

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> OrigNumExpansions =
        ExpansionTL.getTypePtr()->getNumExpansions();
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(
            ExpansionTL.getEllipsisLoc(),
            OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
            RetainExpansion, NumExpansions))
      return ExprError();
    if (Expand) {
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        SubstInitCapture(SourceLocation(), std::nullopt);
      }
    }
    if (!Expand || RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());
      SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
      Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
    }
  } else {
    SubstInitCapture(SourceLocation(), std::nullopt);
  }
}

LambdaScopeInfo *LSI = getSema().PushLambdaScope();
Sema::FunctionScopeRAII FuncScopeCleanup(getSema());

// Create the local class that will describe the lambda.

// FIXME: DependencyKind below is wrong when substituting inside a templated
// context that isn't a DeclContext (such as a variable template), or when
// substituting an unevaluated lambda inside of a function's parameter's type
// - as parameter types are not instantiated from within a function's DC. We
// use evaluation contexts to distinguish the function parameter case.
CXXRecordDecl::LambdaDependencyKind DependencyKind =
    CXXRecordDecl::LDK_Unknown;
if ((getSema().isUnevaluatedContext() ||
     getSema().isConstantEvaluatedContext()) &&
    (getSema().CurContext->isFileContext() ||
     !getSema().CurContext->getParent()->isDependentContext()))
  DependencyKind = CXXRecordDecl::LDK_NeverDependent;

CXXRecordDecl *OldClass = E->getLambdaClass();
CXXRecordDecl *Class = getSema().createLambdaClosureType(
    E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind,
    E->getCaptureDefault());
getDerived().transformedLocalDecl(OldClass, {Class});

CXXMethodDecl *NewCallOperator =
    getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class);
NewCallOperator->setLexicalDeclContext(getSema().CurContext);

// Enter the scope of the lambda.
getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(),
                           E->getCaptureDefault(), E->getCaptureDefaultLoc(),
                           E->hasExplicitParameters(), E->isMutable());

// Introduce the context of the call operator.
Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
                               /*NewThisContext*/false);

bool Invalid = false;

// Transform captures.
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (C->isImplicit())
    break;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
    getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
                                  /*BuildAndDiagnose*/ true, nullptr,
                                  C->getCaptureKind() == LCK_StarThis);
    continue;
  }
  // Captured expression will be recaptured during captured variables
  // rebuilding.
  if (C->capturesVLAType())
    continue;

  // Rebuild init-captures, including the implied field declaration.
  if (E->isInitCapture(C)) {
    TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];

    auto *OldVD = cast<VarDecl>(C->getCapturedVar());
    llvm::SmallVector<Decl*, 4> NewVDs;

    for (InitCaptureInfoTy &Info : NewC.Expansions) {
      ExprResult Init = Info.first;
      QualType InitQualType = Info.second;
      if (Init.isInvalid() || InitQualType.isNull()) {
        Invalid = true;
        break;
      }
      VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
          OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
          OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(),
          getSema().CurContext);
      if (!NewVD) {
        Invalid = true;
        break;
      }
      NewVDs.push_back(NewVD);
      getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef);
    }

    if (Invalid)
      break;

    getDerived().transformedLocalDecl(OldVD, NewVDs);
    continue;
  }

  assert(C->capturesVariable() && "unexpected kind of lambda capture")(static_cast <bool> (C->capturesVariable() &&
 "unexpected kind of lambda capture") ? void (0) : __assert_fail
 ("C->capturesVariable() && \"unexpected kind of lambda capture\""
, "clang/lib/Sema/TreeTransform.h", 13383, __extension__ __PRETTY_FUNCTION__
));

  // Determine the capture kind for Sema.
  Sema::TryCaptureKind Kind
    = C->isImplicit()? Sema::TryCapture_Implicit
                     : C->getCaptureKind() == LCK_ByCopy
                         ? Sema::TryCapture_ExplicitByVal
                         : Sema::TryCapture_ExplicitByRef;
  SourceLocation EllipsisLoc;
  if (C->isPackExpansion()) {
    UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions;
    if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
                                             C->getLocation(),
                                             Unexpanded,
                                             ShouldExpand, RetainExpansion,
                                             NumExpansions)) {
      Invalid = true;
      continue;
    }

    if (ShouldExpand) {
      // The transform has determined that we should perform an expansion;
      // transform and capture each of the arguments.
      // expansion of the pattern. Do so.
      auto *Pack = cast<VarDecl>(C->getCapturedVar());
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        VarDecl *CapturedVar
          = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
                                                             Pack));
        if (!CapturedVar) {
          Invalid = true;
          continue;
        }

        // Capture the transformed variable.
        getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
      }

      // FIXME: Retain a pack expansion if RetainExpansion is true.

      continue;
    }

    EllipsisLoc = C->getEllipsisLoc();
  }

  // Transform the captured variable.
  auto *CapturedVar = cast_or_null<ValueDecl>(
      getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
  if (!CapturedVar || CapturedVar->isInvalidDecl()) {
    Invalid = true;
    continue;
  }

  // Capture the transformed variable.
  getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
                               EllipsisLoc);
}
getSema().finishLambdaExplicitCaptures(LSI);

// Transform the template parameters, and add them to the current
// instantiation scope. The null case is handled correctly.
auto TPL = getDerived().TransformTemplateParameterList(
    E->getTemplateParameterList());
LSI->GLTemplateParameterList = TPL;

// Transform the type of the original lambda's call operator.
// The transformation MUST be done in the CurrentInstantiationScope since
// it introduces a mapping of the original to the newly created
// transformed parameters.
TypeSourceInfo *NewCallOpTSI = nullptr;
{
  TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
  auto OldCallOpFPTL =
      OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();

  TypeLocBuilder NewCallOpTLBuilder;
  SmallVector<QualType, 4> ExceptionStorage;
  TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
  QualType NewCallOpType = TransformFunctionProtoType(
      NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(),
      [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
        return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
                                            ExceptionStorage, Changed);
      });
  if (NewCallOpType.isNull())
    return ExprError();
  NewCallOpTSI =
      NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType);
}

getSema().CompleteLambdaCallOperator(
    NewCallOperator, E->getCallOperator()->getLocation(),
    E->getCallOperator()->getInnerLocStart(),
    E->getCallOperator()->getTrailingRequiresClause(), NewCallOpTSI,
    E->getCallOperator()->getConstexprKind(),
    E->getCallOperator()->getStorageClass(),
    NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
    E->hasExplicitResultType());

getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});

{
  // Number the lambda for linkage purposes if necessary.
  Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext());

  std::optional<CXXRecordDecl::LambdaNumbering> Numbering;
  if (getDerived().ReplacingOriginal()) {
    Numbering = OldClass->getLambdaNumbering();
  }

  getSema().handleLambdaNumbering(Class, NewCallOperator, Numbering);
}

// FIXME: Sema's lambda-building mechanism expects us to push an expression
// evaluation context even if we're not transforming the function body.
getSema().PushExpressionEvaluationContext(
    Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// Instantiate the body of the lambda expression.
StmtResult Body =
    Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody());

// ActOnLambda* will pop the function scope for us.
FuncScopeCleanup.disable();

if (Body.isInvalid()) {
  SavedContext.pop();
  getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr,
                             /*IsInstantiation=*/true);
  return ExprError();
}

// Copy the LSI before ActOnFinishFunctionBody removes it.
// FIXME: This is dumb. Store the lambda information somewhere that outlives
// the call operator.
auto LSICopy = *LSI;
getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
                                  /*IsInstantiation*/ true);
SavedContext.pop();

return getSema().BuildLambdaExpr(E->getBeginLoc(), Body.get()->getEndLoc(),
                                 &LSICopy);
13531}

13533template<typename Derived>
13534StmtResult
13535TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) {
return TransformStmt(S);
13537}

13539template<typename Derived>
13540StmtResult
13541TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) {
// Transform captures.
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (!C->isImplicit())
    continue;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
    getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
                                  /*BuildAndDiagnose*/ true, nullptr,
                                  C->getCaptureKind() == LCK_StarThis);
    continue;
  }
  // Captured expression will be recaptured during captured variables
  // rebuilding.
  if (C->capturesVLAType())
    continue;

  assert(C->capturesVariable() && "unexpected kind of lambda capture")(static_cast <bool> (C->capturesVariable() &&
 "unexpected kind of lambda capture") ? void (0) : __assert_fail
 ("C->capturesVariable() && \"unexpected kind of lambda capture\""
, "clang/lib/Sema/TreeTransform.h", 13563, __extension__ __PRETTY_FUNCTION__
));
  assert(!E->isInitCapture(C) && "implicit init-capture?")(static_cast <bool> (!E->isInitCapture(C) &&
 "implicit init-capture?") ? void (0) : __assert_fail ("!E->isInitCapture(C) && \"implicit init-capture?\""
, "clang/lib/Sema/TreeTransform.h", 13564, __extension__ __PRETTY_FUNCTION__
));

  // Transform the captured variable.
  VarDecl *CapturedVar = cast_or_null<VarDecl>(
      getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
  if (!CapturedVar || CapturedVar->isInvalidDecl())
    return StmtError();

  // Capture the transformed variable.
  getSema().tryCaptureVariable(CapturedVar, C->getLocation());
}

return S;
13577}

13579template<typename Derived>
13580ExprResult
13581TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
                                                CXXUnresolvedConstructExpr *E) {
TypeSourceInfo *T =
    getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (getDerived().TransformExprs(E->arg_begin(), E->getNumArgs(), true, Args,
                                  &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo() &&
    !ArgumentChanged)
  return E;

// FIXME: we're faking the locations of the commas
return getDerived().RebuildCXXUnresolvedConstructExpr(
    T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization());
13608}

13610template<typename Derived>
13611ExprResult
13612TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
                                           CXXDependentScopeMemberExpr *E) {
// Transform the base of the expression.
ExprResult Base((Expr*) nullptr);
Expr *OldBase;
QualType BaseType;
QualType ObjectType;
if (!E->isImplicitAccess()) {
  OldBase = E->getBase();
  Base = getDerived().TransformExpr(OldBase);
  if (Base.isInvalid())
    return ExprError();

  // Start the member reference and compute the object's type.
  ParsedType ObjectTy;
  bool MayBePseudoDestructor = false;
  Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
                                              E->getOperatorLoc(),
                                    E->isArrow()? tok::arrow : tok::period,
                                              ObjectTy,
                                              MayBePseudoDestructor);
  if (Base.isInvalid())
    return ExprError();

  ObjectType = ObjectTy.get();
  BaseType = ((Expr*) Base.get())->getType();
} else {
  OldBase = nullptr;
  BaseType = getDerived().TransformType(E->getBaseType());
  ObjectType = BaseType->castAs<PointerType>()->getPointeeType();
}

// Transform the first part of the nested-name-specifier that qualifies
// the member name.
NamedDecl *FirstQualifierInScope
  = getDerived().TransformFirstQualifierInScope(
                                          E->getFirstQualifierFoundInScope(),
                                          E->getQualifierLoc().getBeginLoc());

NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifier()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
                                                   ObjectType,
                                                   FirstQualifierInScope);
  if (!QualifierLoc)
    return ExprError();
}

SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.

DeclarationNameInfo NameInfo
  = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
if (!NameInfo.getName())
  return ExprError();

if (!E->hasExplicitTemplateArgs()) {
  // This is a reference to a member without an explicitly-specified
  // template argument list. Optimize for this common case.
  if (!getDerived().AlwaysRebuild() &&
      Base.get() == OldBase &&
      BaseType == E->getBaseType() &&
      QualifierLoc == E->getQualifierLoc() &&
      NameInfo.getName() == E->getMember() &&
      FirstQualifierInScope == E->getFirstQualifierFoundInScope())
    return E;

  return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
                                                     BaseType,
                                                     E->isArrow(),
                                                     E->getOperatorLoc(),
                                                     QualifierLoc,
                                                     TemplateKWLoc,
                                                     FirstQualifierInScope,
                                                     NameInfo,
                                                     /*TemplateArgs*/nullptr);
}

TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                            E->getNumTemplateArgs(),
                                            TransArgs))
  return ExprError();

return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
                                                   BaseType,
                                                   E->isArrow(),
                                                   E->getOperatorLoc(),
                                                   QualifierLoc,
                                                   TemplateKWLoc,
                                                   FirstQualifierInScope,
                                                   NameInfo,
                                                   &TransArgs);
13709}

13711template <typename Derived>
13712ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(
  UnresolvedMemberExpr *Old) {
// Transform the base of the expression.
ExprResult Base((Expr *)nullptr);
QualType BaseType;
if (!Old->isImplicitAccess()) {
  Base = getDerived().TransformExpr(Old->getBase());
  if (Base.isInvalid())
    return ExprError();
  Base =
      getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow());
  if (Base.isInvalid())
    return ExprError();
  BaseType = Base.get()->getType();
} else {
  BaseType = getDerived().TransformType(Old->getBaseType());
}

NestedNameSpecifierLoc QualifierLoc;
if (Old->getQualifierLoc()) {
  QualifierLoc =
      getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();

LookupResult R(SemaRef, Old->getMemberNameInfo(), Sema::LookupOrdinaryName);

// Transform the declaration set.
if (TransformOverloadExprDecls(Old, /*RequiresADL*/ false, R))
  return ExprError();

// Determine the naming class.
if (Old->getNamingClass()) {
  CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
      getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
  if (!NamingClass)
    return ExprError();

  R.setNamingClass(NamingClass);
}

TemplateArgumentListInfo TransArgs;
if (Old->hasExplicitTemplateArgs()) {
  TransArgs.setLAngleLoc(Old->getLAngleLoc());
  TransArgs.setRAngleLoc(Old->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(
          Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
    return ExprError();
}

// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;

return getDerived().RebuildUnresolvedMemberExpr(
    Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
    TemplateKWLoc, FirstQualifierInScope, R,
    (Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr));
13775}

13777template<typename Derived>
13778ExprResult
13779TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
  return E;

return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
13790}

13792template<typename Derived>
13793ExprResult
13794TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
if (Pattern.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
  return E;

return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
                                         E->getNumExpansions());
13804}

13806template<typename Derived>
13807ExprResult
13808TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
// If E is not value-dependent, then nothing will change when we transform it.
// Note: This is an instantiation-centric view.
if (!E->isValueDependent())
  return E;

EnterExpressionEvaluationContext Unevaluated(
    getSema(), Sema::ExpressionEvaluationContext::Unevaluated);

ArrayRef<TemplateArgument> PackArgs;
TemplateArgument ArgStorage;

// Find the argument list to transform.
if (E->isPartiallySubstituted()) {
  PackArgs = E->getPartialArguments();
} else if (E->isValueDependent()) {
  UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
  bool ShouldExpand = false;
  bool RetainExpansion = false;
  std::optional<unsigned> NumExpansions;
  if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
                                           Unexpanded,
                                           ShouldExpand, RetainExpansion,
                                           NumExpansions))
    return ExprError();

  // If we need to expand the pack, build a template argument from it and
  // expand that.
  if (ShouldExpand) {
    auto *Pack = E->getPack();
    if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
      ArgStorage = getSema().Context.getPackExpansionType(
          getSema().Context.getTypeDeclType(TTPD), std::nullopt);
    } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
      ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt);
    } else {
      auto *VD = cast<ValueDecl>(Pack);
      ExprResult DRE = getSema().BuildDeclRefExpr(
          VD, VD->getType().getNonLValueExprType(getSema().Context),
          VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue,
          E->getPackLoc());
      if (DRE.isInvalid())
        return ExprError();
      ArgStorage = new (getSema().Context)
          PackExpansionExpr(getSema().Context.DependentTy, DRE.get(),
                            E->getPackLoc(), std::nullopt);
    }
    PackArgs = ArgStorage;
  }
}

// If we're not expanding the pack, just transform the decl.
if (!PackArgs.size()) {
  auto *Pack = cast_or_null<NamedDecl>(
      getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
  if (!Pack)
    return ExprError();
  return getDerived().RebuildSizeOfPackExpr(
      E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(),
      std::nullopt, std::nullopt);
}

// Try to compute the result without performing a partial substitution.
std::optional<unsigned> Result = 0;
for (const TemplateArgument &Arg : PackArgs) {
  if (!Arg.isPackExpansion()) {
    Result = *Result + 1;
    continue;
  }

  TemplateArgumentLoc ArgLoc;
  InventTemplateArgumentLoc(Arg, ArgLoc);

  // Find the pattern of the pack expansion.
  SourceLocation Ellipsis;
  std::optional<unsigned> OrigNumExpansions;
  TemplateArgumentLoc Pattern =
      getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
                                                        OrigNumExpansions);

  // Substitute under the pack expansion. Do not expand the pack (yet).
  TemplateArgumentLoc OutPattern;
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
  if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
                                             /*Uneval*/ true))
    return true;

  // See if we can determine the number of arguments from the result.
  std::optional<unsigned> NumExpansions =
      getSema().getFullyPackExpandedSize(OutPattern.getArgument());
  if (!NumExpansions) {
    // No: we must be in an alias template expansion, and we're going to need
    // to actually expand the packs.
    Result = std::nullopt;
    break;
  }

  Result = *Result + *NumExpansions;
}

// Common case: we could determine the number of expansions without
// substituting.
if (Result)
  return getDerived().RebuildSizeOfPackExpr(
      E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
      *Result, std::nullopt);

TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
                                             E->getPackLoc());
{
  TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
  typedef TemplateArgumentLocInventIterator<
      Derived, const TemplateArgument*> PackLocIterator;
  if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
                                 PackLocIterator(*this, PackArgs.end()),
                                 TransformedPackArgs, /*Uneval*/true))
    return ExprError();
}

// Check whether we managed to fully-expand the pack.
// FIXME: Is it possible for us to do so and not hit the early exit path?
SmallVector<TemplateArgument, 8> Args;
bool PartialSubstitution = false;
for (auto &Loc : TransformedPackArgs.arguments()) {
  Args.push_back(Loc.getArgument());
  if (Loc.getArgument().isPackExpansion())
    PartialSubstitution = true;
}

if (PartialSubstitution)
  return getDerived().RebuildSizeOfPackExpr(
      E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
      std::nullopt, Args);

return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
                                          E->getPackLoc(), E->getRParenLoc(),
                                          Args.size(), std::nullopt);
13945}

13947template<typename Derived>
13948ExprResult
13949TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
                                        SubstNonTypeTemplateParmPackExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
13953}

13955template<typename Derived>
13956ExprResult
13957TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
                                        SubstNonTypeTemplateParmExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
13961}

13963template<typename Derived>
13964ExprResult
13965TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
13968}

13970template<typename Derived>
13971ExprResult
13972TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
                                                MaterializeTemporaryExpr *E) {
return getDerived().TransformExpr(E->getSubExpr());
13975}

13977template<typename Derived>
13978ExprResult
13979TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
UnresolvedLookupExpr *Callee = nullptr;
if (Expr *OldCallee = E->getCallee()) {
  ExprResult CalleeResult = getDerived().TransformExpr(OldCallee);
  if (CalleeResult.isInvalid())
    return ExprError();
  Callee = cast<UnresolvedLookupExpr>(CalleeResult.get());
}

Expr *Pattern = E->getPattern();

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 13992, __extension__ __PRETTY_FUNCTION__
));

// Determine whether the set of unexpanded parameter packs can and should
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
std::optional<unsigned> OrigNumExpansions = E->getNumExpansions(),
                        NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
                                         Pattern->getSourceRange(),
                                         Unexpanded,
                                         Expand, RetainExpansion,
                                         NumExpansions))
  return true;

if (!Expand) {
  // Do not expand any packs here, just transform and rebuild a fold
  // expression.
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

  ExprResult LHS =
      E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
  if (LHS.isInvalid())
    return true;

  ExprResult RHS =
      E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
  if (RHS.isInvalid())
    return true;

  if (!getDerived().AlwaysRebuild() &&
      LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
    return E;

  return getDerived().RebuildCXXFoldExpr(
      Callee, E->getBeginLoc(), LHS.get(), E->getOperator(),
      E->getEllipsisLoc(), RHS.get(), E->getEndLoc(), NumExpansions);
}

// Formally a fold expression expands to nested parenthesized expressions.
// Enforce this limit to avoid creating trees so deep we can't safely traverse
// them.
if (NumExpansions && SemaRef.getLangOpts().BracketDepth < NumExpansions) {
  SemaRef.Diag(E->getEllipsisLoc(),
               clang::diag::err_fold_expression_limit_exceeded)
      << *NumExpansions << SemaRef.getLangOpts().BracketDepth
      << E->getSourceRange();
  SemaRef.Diag(E->getEllipsisLoc(), diag::note_bracket_depth);
  return ExprError();
}

// The transform has determined that we should perform an elementwise
// expansion of the pattern. Do so.
ExprResult Result = getDerived().TransformExpr(E->getInit());
if (Result.isInvalid())
  return true;
bool LeftFold = E->isLeftFold();

// If we're retaining an expansion for a right fold, it is the innermost
// component and takes the init (if any).
if (!LeftFold && RetainExpansion) {
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  Result = getDerived().RebuildCXXFoldExpr(
      Callee, E->getBeginLoc(), Out.get(), E->getOperator(),
      E->getEllipsisLoc(), Result.get(), E->getEndLoc(), OrigNumExpansions);
  if (Result.isInvalid())
    return true;
}

for (unsigned I = 0; I != *NumExpansions; ++I) {
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
      getSema(), LeftFold ? I : *NumExpansions - I - 1);
  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  if (Out.get()->containsUnexpandedParameterPack()) {
    // We still have a pack; retain a pack expansion for this slice.
    Result = getDerived().RebuildCXXFoldExpr(
        Callee, E->getBeginLoc(), LeftFold ? Result.get() : Out.get(),
        E->getOperator(), E->getEllipsisLoc(),
        LeftFold ? Out.get() : Result.get(), E->getEndLoc(),
        OrigNumExpansions);
  } else if (Result.isUsable()) {
    // We've got down to a single element; build a binary operator.
    Expr *LHS = LeftFold ? Result.get() : Out.get();
    Expr *RHS = LeftFold ? Out.get() : Result.get();
    if (Callee)
      Result = getDerived().RebuildCXXOperatorCallExpr(
          BinaryOperator::getOverloadedOperator(E->getOperator()),
          E->getEllipsisLoc(), Callee, LHS, RHS);
    else
      Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(),
                                                  E->getOperator(), LHS, RHS);
  } else
    Result = Out;

  if (Result.isInvalid())
    return true;
}

// If we're retaining an expansion for a left fold, it is the outermost
// component and takes the complete expansion so far as its init (if any).
if (LeftFold && RetainExpansion) {
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  Result = getDerived().RebuildCXXFoldExpr(
      Callee, E->getBeginLoc(), Result.get(), E->getOperator(),
      E->getEllipsisLoc(), Out.get(), E->getEndLoc(), OrigNumExpansions);
  if (Result.isInvalid())
    return true;
}

// If we had no init and an empty pack, and we're not retaining an expansion,
// then produce a fallback value or error.
if (Result.isUnset())
  return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
                                              E->getOperator());

return Result;
14121}

14123template <typename Derived>
14124ExprResult
14125TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) {
SmallVector<Expr *, 4> TransformedInits;
ArrayRef<Expr *> InitExprs = E->getInitExprs();
if (TransformExprs(InitExprs.data(), InitExprs.size(), true,
                   TransformedInits))
  return ExprError();

return getDerived().RebuildParenListExpr(E->getBeginLoc(), TransformedInits,
                                         E->getEndLoc());
14134}

14136template<typename Derived>
14137ExprResult
14138TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
  CXXStdInitializerListExpr *E) {
return getDerived().TransformExpr(E->getSubExpr());
14141}

14143template<typename Derived>
14144ExprResult
14145TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
return SemaRef.MaybeBindToTemporary(E);
14147}

14149template<typename Derived>
14150ExprResult
14151TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
return E;
14153}

14155template<typename Derived>
14156ExprResult
14157TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
14167}

14169template<typename Derived>
14170ExprResult
14171TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
// Transform each of the elements.
SmallVector<Expr *, 8> Elements;
bool ArgChanged = false;
if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
                                /*IsCall=*/false, Elements, &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
                                            Elements.data(),
                                            Elements.size());
14185}

14187template<typename Derived>
14188ExprResult
14189TreeTransform<Derived>::TransformObjCDictionaryLiteral(
                                                  ObjCDictionaryLiteral *E) {
// Transform each of the elements.
SmallVector<ObjCDictionaryElement, 8> Elements;
bool ArgChanged = false;
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
  ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);

  if (OrigElement.isPackExpansion()) {
    // This key/value element is a pack expansion.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
    getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 14202, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can
    // and should be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
                             OrigElement.Value->getEndLoc());
    if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
                                             PatternRange, Unexpanded, Expand,
                                             RetainExpansion, NumExpansions))
      return ExprError();

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
      if (Key.isInvalid())
        return ExprError();

      if (Key.get() != OrigElement.Key)
        ArgChanged = true;

      ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
      if (Value.isInvalid())
        return ExprError();

      if (Value.get() != OrigElement.Value)
        ArgChanged = true;

      ObjCDictionaryElement Expansion = {
        Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
      };
      Elements.push_back(Expansion);
      continue;
    }

    // Record right away that the argument was changed.  This needs
    // to happen even if the array expands to nothing.
    ArgChanged = true;

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
      ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
      if (Key.isInvalid())
        return ExprError();

      ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
      if (Value.isInvalid())
        return ExprError();

      ObjCDictionaryElement Element = {
        Key.get(), Value.get(), SourceLocation(), NumExpansions
      };

      // If any unexpanded parameter packs remain, we still have a
      // pack expansion.
      // FIXME: Can this really happen?
      if (Key.get()->containsUnexpandedParameterPack() ||
          Value.get()->containsUnexpandedParameterPack())
        Element.EllipsisLoc = OrigElement.EllipsisLoc;

      Elements.push_back(Element);
    }

    // FIXME: Retain a pack expansion if RetainExpansion is true.

    // We've finished with this pack expansion.
    continue;
  }

  // Transform and check key.
  ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
  if (Key.isInvalid())
    return ExprError();

  if (Key.get() != OrigElement.Key)
    ArgChanged = true;

  // Transform and check value.
  ExprResult Value
    = getDerived().TransformExpr(OrigElement.Value);
  if (Value.isInvalid())
    return ExprError();

  if (Value.get() != OrigElement.Value)
    ArgChanged = true;

  ObjCDictionaryElement Element = {Key.get(), Value.get(), SourceLocation(),
                                   std::nullopt};
  Elements.push_back(Element);
}

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
                                                 Elements);
14306}

14308template<typename Derived>
14309ExprResult
14310TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
TypeSourceInfo *EncodedTypeInfo
  = getDerived().TransformType(E->getEncodedTypeSourceInfo());
if (!EncodedTypeInfo)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    EncodedTypeInfo == E->getEncodedTypeSourceInfo())
  return E;

return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
                                          EncodedTypeInfo,
                                          E->getRParenLoc());
14323}

14325template<typename Derived>
14326ExprResult TreeTransform<Derived>::
14327TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
// This is a kind of implicit conversion, and it needs to get dropped
// and recomputed for the same general reasons that ImplicitCastExprs
// do, as well a more specific one: this expression is only valid when
// it appears *immediately* as an argument expression.
return getDerived().TransformExpr(E->getSubExpr());
14333}

14335template<typename Derived>
14336ExprResult TreeTransform<Derived>::
14337TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
TypeSourceInfo *TSInfo
  = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!TSInfo)
  return ExprError();

ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
if (Result.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    TSInfo == E->getTypeInfoAsWritten() &&
    Result.get() == E->getSubExpr())
  return E;

return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
                                    E->getBridgeKeywordLoc(), TSInfo,
                                    Result.get());
14355}

14357template <typename Derived>
14358ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
  ObjCAvailabilityCheckExpr *E) {
return E;
14361}

14363template<typename Derived>
14364ExprResult
14365TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
                                &ArgChanged))
  return ExprError();

if (E->getReceiverKind() == ObjCMessageExpr::Class) {
  // Class message: transform the receiver type.
  TypeSourceInfo *ReceiverTypeInfo
    = getDerived().TransformType(E->getClassReceiverTypeInfo());
  if (!ReceiverTypeInfo)
    return ExprError();

  // If nothing changed, just retain the existing message send.
  if (!getDerived().AlwaysRebuild() &&
      ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
    return SemaRef.MaybeBindToTemporary(E);

  // Build a new class message send.
  SmallVector<SourceLocation, 16> SelLocs;
  E->getSelectorLocs(SelLocs);
  return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
                                             E->getSelector(),
                                             SelLocs,
                                             E->getMethodDecl(),
                                             E->getLeftLoc(),
                                             Args,
                                             E->getRightLoc());
}
else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
         E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
  if (!E->getMethodDecl())
    return ExprError();

  // Build a new class message send to 'super'.
  SmallVector<SourceLocation, 16> SelLocs;
  E->getSelectorLocs(SelLocs);
  return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
                                             E->getSelector(),
                                             SelLocs,
                                             E->getReceiverType(),
                                             E->getMethodDecl(),
                                             E->getLeftLoc(),
                                             Args,
                                             E->getRightLoc());
}

// Instance message: transform the receiver
assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&(static_cast <bool> (E->getReceiverKind() == ObjCMessageExpr
::Instance && "Only class and instance messages may be instantiated"
) ? void (0) : __assert_fail ("E->getReceiverKind() == ObjCMessageExpr::Instance && \"Only class and instance messages may be instantiated\""
, "clang/lib/Sema/TreeTransform.h", 14417, __extension__ __PRETTY_FUNCTION__
))
       "Only class and instance messages may be instantiated")(static_cast <bool> (E->getReceiverKind() == ObjCMessageExpr
::Instance && "Only class and instance messages may be instantiated"
) ? void (0) : __assert_fail ("E->getReceiverKind() == ObjCMessageExpr::Instance && \"Only class and instance messages may be instantiated\""
, "clang/lib/Sema/TreeTransform.h", 14417, __extension__ __PRETTY_FUNCTION__
));
ExprResult Receiver
  = getDerived().TransformExpr(E->getInstanceReceiver());
if (Receiver.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing message send.
if (!getDerived().AlwaysRebuild() &&
    Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// Build a new instance message send.
SmallVector<SourceLocation, 16> SelLocs;
E->getSelectorLocs(SelLocs);
return getDerived().RebuildObjCMessageExpr(Receiver.get(),
                                           E->getSelector(),
                                           SelLocs,
                                           E->getMethodDecl(),
                                           E->getLeftLoc(),
                                           Args,
                                           E->getRightLoc());
14438}

14440template<typename Derived>
14441ExprResult
14442TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
return E;
14444}

14446template<typename Derived>
14447ExprResult
14448TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
return E;
14450}

14452template<typename Derived>
14453ExprResult
14454TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// We don't need to transform the ivar; it will never change.

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
                                           E->getLocation(),
                                           E->isArrow(), E->isFreeIvar());
14470}

14472template<typename Derived>
14473ExprResult
14474TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
// 'super' and types never change. Property never changes. Just
// retain the existing expression.
if (!E->isObjectReceiver())
  return E;

// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// We don't need to transform the property; it will never change.

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

if (E->isExplicitProperty())
  return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
                                                 E->getExplicitProperty(),
                                                 E->getLocation());

return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
                                               SemaRef.Context.PseudoObjectTy,
                                               E->getImplicitPropertyGetter(),
                                               E->getImplicitPropertySetter(),
                                               E->getLocation());
14502}

14504template<typename Derived>
14505ExprResult
14506TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
  return ExprError();

// Transform the key expression.
ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
if (Key.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
  return E;

return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
                                                Base.get(), Key.get(),
                                                E->getAtIndexMethodDecl(),
                                                E->setAtIndexMethodDecl());
14526}

14528template<typename Derived>
14529ExprResult
14530TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
                                       E->getOpLoc(),
                                       E->isArrow());
14544}

14546template<typename Derived>
14547ExprResult
14548TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 8> SubExprs;
SubExprs.reserve(E->getNumSubExprs());
if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
                                SubExprs, &ArgumentChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    !ArgumentChanged)
  return E;

return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
                                             SubExprs,
                                             E->getRParenLoc());
14563}

14565template<typename Derived>
14566ExprResult
14567TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
if (SrcExpr.isInvalid())
  return ExprError();

TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
if (!Type)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeSourceInfo() &&
    SrcExpr.get() == E->getSrcExpr())
  return E;

return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
                                             SrcExpr.get(), Type,
                                             E->getRParenLoc());
14584}

14586template<typename Derived>
14587ExprResult
14588TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
BlockDecl *oldBlock = E->getBlockDecl();

SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
BlockScopeInfo *blockScope = SemaRef.getCurBlock();

blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
blockScope->TheDecl->setBlockMissingReturnType(
                       oldBlock->blockMissingReturnType());

SmallVector<ParmVarDecl*, 4> params;
SmallVector<QualType, 4> paramTypes;

const FunctionProtoType *exprFunctionType = E->getFunctionType();

// Parameter substitution.
Sema::ExtParameterInfoBuilder extParamInfos;
if (getDerived().TransformFunctionTypeParams(
        E->getCaretLocation(), oldBlock->parameters(), nullptr,
        exprFunctionType->getExtParameterInfosOrNull(), paramTypes, &params,
        extParamInfos)) {
  getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
  return ExprError();
}

QualType exprResultType =
    getDerived().TransformType(exprFunctionType->getReturnType());

auto epi = exprFunctionType->getExtProtoInfo();
epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());

QualType functionType =
  getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
blockScope->FunctionType = functionType;

// Set the parameters on the block decl.
if (!params.empty())
  blockScope->TheDecl->setParams(params);

if (!oldBlock->blockMissingReturnType()) {
  blockScope->HasImplicitReturnType = false;
  blockScope->ReturnType = exprResultType;
}

// Transform the body
StmtResult body = getDerived().TransformStmt(E->getBody());
if (body.isInvalid()) {
  getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
  return ExprError();
}

14639#ifndef NDEBUG
// In builds with assertions, make sure that we captured everything we
// captured before.
if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
  for (const auto &I : oldBlock->captures()) {
    VarDecl *oldCapture = I.getVariable();

    // Ignore parameter packs.
    if (oldCapture->isParameterPack())
      continue;

    VarDecl *newCapture =
      cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
                                               oldCapture));
    assert(blockScope->CaptureMap.count(newCapture))(static_cast <bool> (blockScope->CaptureMap.count(newCapture
)) ? void (0) : __assert_fail ("blockScope->CaptureMap.count(newCapture)"
, "clang/lib/Sema/TreeTransform.h", 14653, __extension__ __PRETTY_FUNCTION__
));
  }

  // The this pointer may not be captured by the instantiated block, even when
  // it's captured by the original block, if the expression causing the
  // capture is in the discarded branch of a constexpr if statement.
  assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) &&(static_cast <bool> ((!blockScope->isCXXThisCaptured
() || oldBlock->capturesCXXThis()) && "this pointer isn't captured in the old block"
) ? void (0) : __assert_fail ("(!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) && \"this pointer isn't captured in the old block\""
, "clang/lib/Sema/TreeTransform.h", 14660, __extension__ __PRETTY_FUNCTION__
))
         "this pointer isn't captured in the old block")(static_cast <bool> ((!blockScope->isCXXThisCaptured
() || oldBlock->capturesCXXThis()) && "this pointer isn't captured in the old block"
) ? void (0) : __assert_fail ("(!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) && \"this pointer isn't captured in the old block\""
, "clang/lib/Sema/TreeTransform.h", 14660, __extension__ __PRETTY_FUNCTION__
));
}
14662#endif

return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
                                  /*Scope=*/nullptr);
14666}

14668template<typename Derived>
14669ExprResult
14670TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
if (SrcExpr.isInvalid())
  return ExprError();

QualType Type = getDerived().TransformType(E->getType());

return SemaRef.BuildAsTypeExpr(SrcExpr.get(), Type, E->getBuiltinLoc(),
                               E->getRParenLoc());
14679}

14681template<typename Derived>
14682ExprResult
14683TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 8> SubExprs;
SubExprs.reserve(E->getNumSubExprs());
if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
                                SubExprs, &ArgumentChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    !ArgumentChanged)
  return E;

return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
                                      E->getOp(), E->getRParenLoc());
14697}

14699//===----------------------------------------------------------------------===//
14700// Type reconstruction
14701//===----------------------------------------------------------------------===//

14703template<typename Derived>
14704QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
                                                  SourceLocation Star) {
return SemaRef.BuildPointerType(PointeeType, Star,
                                getDerived().getBaseEntity());
14708}

14710template<typename Derived>
14711QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
                                                       SourceLocation Star) {
return SemaRef.BuildBlockPointerType(PointeeType, Star,
                                     getDerived().getBaseEntity());
14715}

14717template<typename Derived>
14718QualType
14719TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
                                           bool WrittenAsLValue,
                                           SourceLocation Sigil) {
return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
                                  Sigil, getDerived().getBaseEntity());
14724}

14726template<typename Derived>
14727QualType
14728TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
                                               QualType ClassType,
                                               SourceLocation Sigil) {
return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
                                      getDerived().getBaseEntity());
14733}

14735template<typename Derived>
14736QualType TreeTransform<Derived>::RebuildObjCTypeParamType(
         const ObjCTypeParamDecl *Decl,
         SourceLocation ProtocolLAngleLoc,
         ArrayRef<ObjCProtocolDecl *> Protocols,
         ArrayRef<SourceLocation> ProtocolLocs,
         SourceLocation ProtocolRAngleLoc) {
return SemaRef.BuildObjCTypeParamType(Decl,
                                      ProtocolLAngleLoc, Protocols,
                                      ProtocolLocs, ProtocolRAngleLoc,
                                      /*FailOnError=*/true);
14746}

14748template<typename Derived>
14749QualType TreeTransform<Derived>::RebuildObjCObjectType(
         QualType BaseType,
         SourceLocation Loc,
         SourceLocation TypeArgsLAngleLoc,
         ArrayRef<TypeSourceInfo *> TypeArgs,
         SourceLocation TypeArgsRAngleLoc,
         SourceLocation ProtocolLAngleLoc,
         ArrayRef<ObjCProtocolDecl *> Protocols,
         ArrayRef<SourceLocation> ProtocolLocs,
         SourceLocation ProtocolRAngleLoc) {
return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, TypeArgs,
                                   TypeArgsRAngleLoc, ProtocolLAngleLoc,
                                   Protocols, ProtocolLocs, ProtocolRAngleLoc,
                                   /*FailOnError=*/true,
                                   /*Rebuilding=*/true);
14764}

14766template<typename Derived>
14767QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
         QualType PointeeType,
         SourceLocation Star) {
return SemaRef.Context.getObjCObjectPointerType(PointeeType);
14771}

14773template<typename Derived>
14774QualType
14775TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
                                       ArrayType::ArraySizeModifier SizeMod,
                                       const llvm::APInt *Size,
                                       Expr *SizeExpr,
                                       unsigned IndexTypeQuals,
                                       SourceRange BracketsRange) {
if (SizeExpr || !Size)
  return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
                                IndexTypeQuals, BracketsRange,
                                getDerived().getBaseEntity());

QualType Types[] = {
  SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
  SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
  SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
};
QualType SizeType;
for (const auto &T : Types)
  if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) {
    SizeType = T;
    break;
  }

// Note that we can return a VariableArrayType here in the case where
// the element type was a dependent VariableArrayType.
IntegerLiteral *ArraySize
    = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType,
                             /*FIXME*/BracketsRange.getBegin());
return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
                              IndexTypeQuals, BracketsRange,
                              getDerived().getBaseEntity());
14806}

14808template<typename Derived>
14809QualType
14810TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
                                               ArrayType::ArraySizeModifier SizeMod,
                                               const llvm::APInt &Size,
                                               Expr *SizeExpr,
                                               unsigned IndexTypeQuals,
                                               SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
                                      IndexTypeQuals, BracketsRange);
14818}

14820template<typename Derived>
14821QualType
14822TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                               unsigned IndexTypeQuals,
                                                 SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
                                     IndexTypeQuals, BracketsRange);
14828}

14830template<typename Derived>
14831QualType
14832TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                               Expr *SizeExpr,
                                               unsigned IndexTypeQuals,
                                               SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
                                     SizeExpr,
                                     IndexTypeQuals, BracketsRange);
14840}

14842template<typename Derived>
14843QualType
14844TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                                     Expr *SizeExpr,
                                                     unsigned IndexTypeQuals,
                                                 SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
                                     SizeExpr,
                                     IndexTypeQuals, BracketsRange);
14852}

14854template <typename Derived>
14855QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType(
  QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
return SemaRef.BuildAddressSpaceAttr(PointeeType, AddrSpaceExpr,
                                        AttributeLoc);
14859}

14861template <typename Derived>
14862QualType
14863TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
                                        unsigned NumElements,
                                        VectorType::VectorKind VecKind) {
// FIXME: semantic checking!
return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
14868}

14870template <typename Derived>
14871QualType TreeTransform<Derived>::RebuildDependentVectorType(
  QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc,
  VectorType::VectorKind VecKind) {
return SemaRef.BuildVectorType(ElementType, SizeExpr, AttributeLoc);
14875}

14877template<typename Derived>
14878QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
                                                    unsigned NumElements,
                                               SourceLocation AttributeLoc) {
llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
                        NumElements, true);
IntegerLiteral *VectorSize
  = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy,
                           AttributeLoc);
return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
14887}

14889template<typename Derived>
14890QualType
14891TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
                                                         Expr *SizeExpr,
                                                SourceLocation AttributeLoc) {
return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
14895}

14897template <typename Derived>
14898QualType TreeTransform<Derived>::RebuildConstantMatrixType(
  QualType ElementType, unsigned NumRows, unsigned NumColumns) {
return SemaRef.Context.getConstantMatrixType(ElementType, NumRows,
                                             NumColumns);
14902}

14904template <typename Derived>
14905QualType TreeTransform<Derived>::RebuildDependentSizedMatrixType(
  QualType ElementType, Expr *RowExpr, Expr *ColumnExpr,
  SourceLocation AttributeLoc) {
return SemaRef.BuildMatrixType(ElementType, RowExpr, ColumnExpr,
                               AttributeLoc);
14910}

14912template<typename Derived>
14913QualType TreeTransform<Derived>::RebuildFunctionProtoType(
  QualType T,
  MutableArrayRef<QualType> ParamTypes,
  const FunctionProtoType::ExtProtoInfo &EPI) {
return SemaRef.BuildFunctionType(T, ParamTypes,
                                 getDerived().getBaseLocation(),
                                 getDerived().getBaseEntity(),
                                 EPI);
14921}

14923template<typename Derived>
14924QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
return SemaRef.Context.getFunctionNoProtoType(T);
14926}

14928template<typename Derived>
14929QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc,
                                                          Decl *D) {
assert(D && "no decl found")(static_cast <bool> (D && "no decl found") ? void
 (0) : __assert_fail ("D && \"no decl found\"", "clang/lib/Sema/TreeTransform.h"
, 14931, __extension__ __PRETTY_FUNCTION__));
if (D->isInvalidDecl()) return QualType();

// FIXME: Doesn't account for ObjCInterfaceDecl!
if (auto *UPD = dyn_cast<UsingPackDecl>(D)) {
  // A valid resolved using typename pack expansion decl can have multiple
  // UsingDecls, but they must each have exactly one type, and it must be
  // the same type in every case. But we must have at least one expansion!
  if (UPD->expansions().empty()) {
    getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
        << UPD->isCXXClassMember() << UPD;
    return QualType();
  }

  // We might still have some unresolved types. Try to pick a resolved type
  // if we can. The final instantiation will check that the remaining
  // unresolved types instantiate to the type we pick.
  QualType FallbackT;
  QualType T;
  for (auto *E : UPD->expansions()) {
    QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
    if (ThisT.isNull())
      continue;
    else if (ThisT->getAs<UnresolvedUsingType>())
      FallbackT = ThisT;
    else if (T.isNull())
      T = ThisT;
    else
      assert(getSema().Context.hasSameType(ThisT, T) &&(static_cast <bool> (getSema().Context.hasSameType(ThisT
, T) && "mismatched resolved types in using pack expansion"
) ? void (0) : __assert_fail ("getSema().Context.hasSameType(ThisT, T) && \"mismatched resolved types in using pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 14960, __extension__ __PRETTY_FUNCTION__
))
             "mismatched resolved types in using pack expansion")(static_cast <bool> (getSema().Context.hasSameType(ThisT
, T) && "mismatched resolved types in using pack expansion"
) ? void (0) : __assert_fail ("getSema().Context.hasSameType(ThisT, T) && \"mismatched resolved types in using pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 14960, __extension__ __PRETTY_FUNCTION__
));
  }
  return T.isNull() ? FallbackT : T;
} else if (auto *Using = dyn_cast<UsingDecl>(D)) {
  assert(Using->hasTypename() &&(static_cast <bool> (Using->hasTypename() &&
 "UnresolvedUsingTypenameDecl transformed to non-typename using"
) ? void (0) : __assert_fail ("Using->hasTypename() && \"UnresolvedUsingTypenameDecl transformed to non-typename using\""
, "clang/lib/Sema/TreeTransform.h", 14965, __extension__ __PRETTY_FUNCTION__
))
         "UnresolvedUsingTypenameDecl transformed to non-typename using")(static_cast <bool> (Using->hasTypename() &&
 "UnresolvedUsingTypenameDecl transformed to non-typename using"
) ? void (0) : __assert_fail ("Using->hasTypename() && \"UnresolvedUsingTypenameDecl transformed to non-typename using\""
, "clang/lib/Sema/TreeTransform.h", 14965, __extension__ __PRETTY_FUNCTION__
));

  // A valid resolved using typename decl points to exactly one type decl.
  assert(++Using->shadow_begin() == Using->shadow_end())(static_cast <bool> (++Using->shadow_begin() == Using
->shadow_end()) ? void (0) : __assert_fail ("++Using->shadow_begin() == Using->shadow_end()"
, "clang/lib/Sema/TreeTransform.h", 14968, __extension__ __PRETTY_FUNCTION__
));

  UsingShadowDecl *Shadow = *Using->shadow_begin();
  if (SemaRef.DiagnoseUseOfDecl(Shadow->getTargetDecl(), Loc))
    return QualType();
  return SemaRef.Context.getUsingType(
      Shadow, SemaRef.Context.getTypeDeclType(
                  cast<TypeDecl>(Shadow->getTargetDecl())));
} else {
  assert(isa<UnresolvedUsingTypenameDecl>(D) &&(static_cast <bool> (isa<UnresolvedUsingTypenameDecl
>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"
) ? void (0) : __assert_fail ("isa<UnresolvedUsingTypenameDecl>(D) && \"UnresolvedUsingTypenameDecl transformed to non-using decl\""
, "clang/lib/Sema/TreeTransform.h", 14978, __extension__ __PRETTY_FUNCTION__
))
         "UnresolvedUsingTypenameDecl transformed to non-using decl")(static_cast <bool> (isa<UnresolvedUsingTypenameDecl
>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"
) ? void (0) : __assert_fail ("isa<UnresolvedUsingTypenameDecl>(D) && \"UnresolvedUsingTypenameDecl transformed to non-using decl\""
, "clang/lib/Sema/TreeTransform.h", 14978, __extension__ __PRETTY_FUNCTION__
));
  return SemaRef.Context.getTypeDeclType(
      cast<UnresolvedUsingTypenameDecl>(D));
}
14982}

14984template <typename Derived>
14985QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, SourceLocation,
                                                     TypeOfKind Kind) {
return SemaRef.BuildTypeofExprType(E, Kind);
14988}

14990template<typename Derived>
14991QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying,
                                                 TypeOfKind Kind) {
return SemaRef.Context.getTypeOfType(Underlying, Kind);
14994}

14996template <typename Derived>
14997QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, SourceLocation) {
return SemaRef.BuildDecltypeType(E);
14999}

15001template<typename Derived>
15002QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
                                          UnaryTransformType::UTTKind UKind,
                                          SourceLocation Loc) {
return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
15006}

15008template<typename Derived>
15009QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
                                                    TemplateName Template,
                                           SourceLocation TemplateNameLoc,
                                   TemplateArgumentListInfo &TemplateArgs) {
return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
15014}

15016template<typename Derived>
15017QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
                                                 SourceLocation KWLoc) {
return SemaRef.BuildAtomicType(ValueType, KWLoc);
15020}

15022template<typename Derived>
15023QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
                                               SourceLocation KWLoc,
                                               bool isReadPipe) {
return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc)
                  : SemaRef.BuildWritePipeType(ValueType, KWLoc);
15028}

15030template <typename Derived>
15031QualType TreeTransform<Derived>::RebuildBitIntType(bool IsUnsigned,
                                                 unsigned NumBits,
                                                 SourceLocation Loc) {
llvm::APInt NumBitsAP(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
                      NumBits, true);
IntegerLiteral *Bits = IntegerLiteral::Create(SemaRef.Context, NumBitsAP,
                                              SemaRef.Context.IntTy, Loc);
return SemaRef.BuildBitIntType(IsUnsigned, Bits, Loc);
15039}

15041template <typename Derived>
15042QualType TreeTransform<Derived>::RebuildDependentBitIntType(
  bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc) {
return SemaRef.BuildBitIntType(IsUnsigned, NumBitsExpr, Loc);
15045}

15047template<typename Derived>
15048TemplateName
15049TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          bool TemplateKW,
                                          TemplateDecl *Template) {
return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
                                                TemplateName(Template));
15054}

15056template<typename Derived>
15057TemplateName
15058TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          SourceLocation TemplateKWLoc,
                                          const IdentifierInfo &Name,
                                          SourceLocation NameLoc,
                                          QualType ObjectType,
                                          NamedDecl *FirstQualifierInScope,
                                          bool AllowInjectedClassName) {
UnqualifiedId TemplateName;
TemplateName.setIdentifier(&Name, NameLoc);
Sema::TemplateTy Template;
getSema().ActOnTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc,
                            TemplateName, ParsedType::make(ObjectType),
                            /*EnteringContext=*/false, Template,
                            AllowInjectedClassName);
return Template.get();
15073}

15075template<typename Derived>
15076TemplateName
15077TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          SourceLocation TemplateKWLoc,
                                          OverloadedOperatorKind Operator,
                                          SourceLocation NameLoc,
                                          QualType ObjectType,
                                          bool AllowInjectedClassName) {
UnqualifiedId Name;
// FIXME: Bogus location information.
SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
Sema::TemplateTy Template;
getSema().ActOnTemplateName(
    /*Scope=*/nullptr, SS, TemplateKWLoc, Name, ParsedType::make(ObjectType),
    /*EnteringContext=*/false, Template, AllowInjectedClassName);
return Template.get();
15092}

15094template<typename Derived>
15095ExprResult
15096TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
                                                 SourceLocation OpLoc,
                                                 Expr *OrigCallee,
                                                 Expr *First,
                                                 Expr *Second) {
Expr *Callee = OrigCallee->IgnoreParenCasts();
bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);

if (First->getObjectKind() == OK_ObjCProperty) {
  BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
  if (BinaryOperator::isAssignmentOp(Opc))
    return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc,
                                               First, Second);
  ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
  if (Result.isInvalid())
    return ExprError();
  First = Result.get();
}

if (Second && Second->getObjectKind() == OK_ObjCProperty) {
  ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
  if (Result.isInvalid())
    return ExprError();
  Second = Result.get();
}

// Determine whether this should be a builtin operation.
if (Op == OO_Subscript) {
  if (!First->getType()->isOverloadableType() &&
      !Second->getType()->isOverloadableType())
    return getSema().CreateBuiltinArraySubscriptExpr(
        First, Callee->getBeginLoc(), Second, OpLoc);
} else if (Op == OO_Arrow) {
  // It is possible that the type refers to a RecoveryExpr created earlier
  // in the tree transformation.
  if (First->getType()->isDependentType())
    return ExprError();
  // -> is never a builtin operation.
  return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
} else if (Second == nullptr || isPostIncDec) {
  if (!First->getType()->isOverloadableType() ||
      (Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) {
    // The argument is not of overloadable type, or this is an expression
    // of the form &Class::member, so try to create a built-in unary
    // operation.
    UnaryOperatorKind Opc
      = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);

    return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
  }
} else {
  if (!First->getType()->isOverloadableType() &&
      !Second->getType()->isOverloadableType()) {
    // Neither of the arguments is an overloadable type, so try to
    // create a built-in binary operation.
    BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
    ExprResult Result
      = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
    if (Result.isInvalid())
      return ExprError();

    return Result;
  }
}

// Compute the transformed set of functions (and function templates) to be
// used during overload resolution.
UnresolvedSet<16> Functions;
bool RequiresADL;

if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
  Functions.append(ULE->decls_begin(), ULE->decls_end());
  // If the overload could not be resolved in the template definition
  // (because we had a dependent argument), ADL is performed as part of
  // template instantiation.
  RequiresADL = ULE->requiresADL();
} else {
  // If we've resolved this to a particular non-member function, just call
  // that function. If we resolved it to a member function,
  // CreateOverloaded* will find that function for us.
  NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
  if (!isa<CXXMethodDecl>(ND))
    Functions.addDecl(ND);
  RequiresADL = false;
}

// Add any functions found via argument-dependent lookup.
Expr *Args[2] = { First, Second };
unsigned NumArgs = 1 + (Second != nullptr);

// Create the overloaded operator invocation for unary operators.
if (NumArgs == 1 || isPostIncDec) {
  UnaryOperatorKind Opc
    = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
  return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First,
                                         RequiresADL);
}

if (Op == OO_Subscript) {
  SourceLocation LBrace;
  SourceLocation RBrace;

  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
    DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
    LBrace = NameLoc.getCXXOperatorNameBeginLoc();
    RBrace = NameLoc.getCXXOperatorNameEndLoc();
  } else {
    LBrace = Callee->getBeginLoc();
    RBrace = OpLoc;
  }

  return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
                                                    First, Second);
}

// Create the overloaded operator invocation for binary operators.
BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
ExprResult Result = SemaRef.CreateOverloadedBinOp(
    OpLoc, Opc, Functions, Args[0], Args[1], RequiresADL);
if (Result.isInvalid())
  return ExprError();

return Result;
15219}

15221template<typename Derived>
15222ExprResult
15223TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
                                                   SourceLocation OperatorLoc,
                                                     bool isArrow,
                                                     CXXScopeSpec &SS,
                                                   TypeSourceInfo *ScopeType,
                                                     SourceLocation CCLoc,
                                                     SourceLocation TildeLoc,
                                      PseudoDestructorTypeStorage Destroyed) {
QualType BaseType = Base->getType();
if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
    (!isArrow && !BaseType->getAs<RecordType>()) ||
    (isArrow && BaseType->getAs<PointerType>() &&
     !BaseType->castAs<PointerType>()->getPointeeType()
                                            ->template getAs<RecordType>())){
  // This pseudo-destructor expression is still a pseudo-destructor.
  return SemaRef.BuildPseudoDestructorExpr(
      Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
      CCLoc, TildeLoc, Destroyed);
}

TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
               SemaRef.Context.getCanonicalType(DestroyedType->getType())));
DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
NameInfo.setNamedTypeInfo(DestroyedType);

// The scope type is now known to be a valid nested name specifier
// component. Tack it on to the end of the nested name specifier.
if (ScopeType) {
  if (!ScopeType->getType()->getAs<TagType>()) {
    getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
                   diag::err_expected_class_or_namespace)
        << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
    return ExprError();
  }
  SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
            CCLoc);
}

SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
return getSema().BuildMemberReferenceExpr(Base, BaseType,
                                          OperatorLoc, isArrow,
                                          SS, TemplateKWLoc,
                                          /*FIXME: FirstQualifier*/ nullptr,
                                          NameInfo,
                                          /*TemplateArgs*/ nullptr,
                                          /*S*/nullptr);
15270}

15272template<typename Derived>
15273StmtResult
15274TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
SourceLocation Loc = S->getBeginLoc();
CapturedDecl *CD = S->getCapturedDecl();
unsigned NumParams = CD->getNumParams();
unsigned ContextParamPos = CD->getContextParamPosition();
SmallVector<Sema::CapturedParamNameType, 4> Params;
for (unsigned I = 0; I < NumParams; ++I) {
  if (I != ContextParamPos) {
    Params.push_back(
           std::make_pair(
                CD->getParam(I)->getName(),
                getDerived().TransformType(CD->getParam(I)->getType())));
  } else {
    Params.push_back(std::make_pair(StringRef(), QualType()));
  }
}
getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
                                   S->getCapturedRegionKind(), Params);
StmtResult Body;
{
  Sema::CompoundScopeRAII CompoundScope(getSema());
  Body = getDerived().TransformStmt(S->getCapturedStmt());
}

if (Body.isInvalid()) {
  getSema().ActOnCapturedRegionError();
  return StmtError();
}

return getSema().ActOnCapturedRegionEnd(Body.get());
15304}

15306} // end namespace clang

15308#endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H

←

tools/clang/include/clang/AST/TypeNodes.inc

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|*                                                                            *|
3|* An x-macro database of Clang type nodes                                    *|
4|*                                                                            *|
5|* Automatically generated file, do not edit!                                 *|
6|*                                                                            *|
7\*===----------------------------------------------------------------------===*/
8 
9#ifndef ABSTRACT_TYPE
10#  define ABSTRACT_TYPE(Class, Base) TYPE(Class, Base)
11#endif
12#ifndef NON_CANONICAL_TYPE
13#  define NON_CANONICAL_TYPE(Class, Base) TYPE(Class, Base)
14#endif
15#ifndef DEPENDENT_TYPE
16#  define DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
17#endif
18#ifndef NON_CANONICAL_UNLESS_DEPENDENT_TYPE
19#  define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
20#endif
21NON_CANONICAL_TYPE(Adjusted, Type)
22NON_CANONICAL_TYPE(Decayed, AdjustedType)
23ABSTRACT_TYPE(Array, Type)
24TYPE(ConstantArray, ArrayType)
25DEPENDENT_TYPE(DependentSizedArray, ArrayType)
26TYPE(IncompleteArray, ArrayType)
27TYPE(VariableArray, ArrayType)
28TYPE(Atomic, Type)
29NON_CANONICAL_TYPE(Attributed, Type)
30NON_CANONICAL_TYPE(BTFTagAttributed, Type)
31TYPE(BitInt, Type)
32TYPE(BlockPointer, Type)
33TYPE(Builtin, Type)
34TYPE(Complex, Type)
35NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Decltype, Type)
36ABSTRACT_TYPE(Deduced, Type)
37TYPE(Auto, DeducedType)
38TYPE(DeducedTemplateSpecialization, DeducedType)
39DEPENDENT_TYPE(DependentAddressSpace, Type)
40DEPENDENT_TYPE(DependentBitInt, Type)
41DEPENDENT_TYPE(DependentName, Type)
42DEPENDENT_TYPE(DependentSizedExtVector, Type)
43DEPENDENT_TYPE(DependentTemplateSpecialization, Type)
44DEPENDENT_TYPE(DependentVector, Type)
45NON_CANONICAL_TYPE(Elaborated, Type)
46ABSTRACT_TYPE(Function, Type)
47TYPE(FunctionNoProto, FunctionType)
48TYPE(FunctionProto, FunctionType)
49DEPENDENT_TYPE(InjectedClassName, Type)
50NON_CANONICAL_TYPE(MacroQualified, Type)
51ABSTRACT_TYPE(Matrix, Type)
52TYPE(ConstantMatrix, MatrixType)
53DEPENDENT_TYPE(DependentSizedMatrix, MatrixType)
54TYPE(MemberPointer, Type)
55TYPE(ObjCObjectPointer, Type)
56TYPE(ObjCObject, Type)
57TYPE(ObjCInterface, ObjCObjectType)
58NON_CANONICAL_TYPE(ObjCTypeParam, Type)
59DEPENDENT_TYPE(PackExpansion, Type)
60NON_CANONICAL_TYPE(Paren, Type)
61TYPE(Pipe, Type)
62TYPE(Pointer, Type)
63ABSTRACT_TYPE(Reference, Type)
64TYPE(LValueReference, ReferenceType)
65TYPE(RValueReference, ReferenceType)
66DEPENDENT_TYPE(SubstTemplateTypeParmPack, Type)
67NON_CANONICAL_TYPE(SubstTemplateTypeParm, Type)
68ABSTRACT_TYPE(Tag, Type)
69TYPE(Enum, TagType)
70TYPE(Record, TagType)
71NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TemplateSpecialization, Type)
72DEPENDENT_TYPE(TemplateTypeParm, Type)
73NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOfExpr, Type)
74NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOf, Type)
16
←
Calling 'TreeTransform::TransformTypeOfType'→
75NON_CANONICAL_TYPE(Typedef, Type)
76NON_CANONICAL_UNLESS_DEPENDENT_TYPE(UnaryTransform, Type)
77DEPENDENT_TYPE(UnresolvedUsing, Type)
78NON_CANONICAL_TYPE(Using, Type)
79TYPE(Vector, Type)
80TYPE(ExtVector, VectorType)
81#ifdef LAST_TYPE
82LAST_TYPE(ExtVector)
83#undef LAST_TYPE
84#endif
85#ifdef LEAF_TYPE
86LEAF_TYPE(Builtin)
87LEAF_TYPE(Enum)
88LEAF_TYPE(InjectedClassName)
89LEAF_TYPE(ObjCInterface)
90LEAF_TYPE(Record)
91LEAF_TYPE(TemplateTypeParm)
92#undef LEAF_TYPE
93#endif
94#undef TYPE
95#undef ABSTRACT_TYPE
96#undef ABSTRACT_TYPE
97#undef NON_CANONICAL_TYPE
98#undef DEPENDENT_TYPE
99#undef NON_CANONICAL_UNLESS_DEPENDENT_TYPE