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

Bug Summary

File:	build/source/clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:	line 1271, column 15 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 SemaTemplateInstantiate.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/SemaTemplateInstantiate.cpp

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

→

1//===------- SemaTemplateInstantiate.cpp - C++ Template 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.
9//
10//===----------------------------------------------------------------------===/

12#include "TreeTransform.h"
13#include "clang/AST/ASTConcept.h"
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTLambda.h"
17#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/DeclBase.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/Expr.h"
21#include "clang/AST/ExprConcepts.h"
22#include "clang/AST/PrettyDeclStackTrace.h"
23#include "clang/AST/Type.h"
24#include "clang/AST/TypeVisitor.h"
25#include "clang/Basic/LangOptions.h"
26#include "clang/Basic/Stack.h"
27#include "clang/Basic/TargetInfo.h"
28#include "clang/Sema/DeclSpec.h"
29#include "clang/Sema/EnterExpressionEvaluationContext.h"
30#include "clang/Sema/Initialization.h"
31#include "clang/Sema/Lookup.h"
32#include "clang/Sema/Sema.h"
33#include "clang/Sema/SemaConcept.h"
34#include "clang/Sema/SemaInternal.h"
35#include "clang/Sema/Template.h"
36#include "clang/Sema/TemplateDeduction.h"
37#include "clang/Sema/TemplateInstCallback.h"
38#include "llvm/ADT/ScopeExit.h"
39#include "llvm/Support/ErrorHandling.h"
40#include "llvm/Support/TimeProfiler.h"
41#include <optional>

43using namespace clang;
44using namespace sema;

46//===----------------------------------------------------------------------===/
47// Template Instantiation Support
48//===----------------------------------------------------------------------===/

50namespace {
51namespace TemplateInstArgsHelpers {
52struct Response {
const Decl *NextDecl = nullptr;
bool IsDone = false;
bool ClearRelativeToPrimary = true;
static Response Done() {
  Response R;
  R.IsDone = true;
  return R;
}
static Response ChangeDecl(const Decl *ND) {
  Response R;
  R.NextDecl = ND;
  return R;
}
static Response ChangeDecl(const DeclContext *Ctx) {
  Response R;
  R.NextDecl = Decl::castFromDeclContext(Ctx);
  return R;
}

static Response UseNextDecl(const Decl *CurDecl) {
  return ChangeDecl(CurDecl->getDeclContext());
}

static Response DontClearRelativeToPrimaryNextDecl(const Decl *CurDecl) {
  Response R = Response::UseNextDecl(CurDecl);
  R.ClearRelativeToPrimary = false;
  return R;
}
81};
82// Add template arguments from a variable template instantiation.
83Response
84HandleVarTemplateSpec(const VarTemplateSpecializationDecl *VarTemplSpec,
                    MultiLevelTemplateArgumentList &Result,
                    bool SkipForSpecialization) {
// For a class-scope explicit specialization, there are no template arguments
// at this level, but there may be enclosing template arguments.
if (VarTemplSpec->isClassScopeExplicitSpecialization())
  return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);

// We're done when we hit an explicit specialization.
if (VarTemplSpec->getSpecializationKind() == TSK_ExplicitSpecialization &&
    !isa<VarTemplatePartialSpecializationDecl>(VarTemplSpec))
  return Response::Done();

// If this variable template specialization was instantiated from a
// specialized member that is a variable template, we're done.
assert(VarTemplSpec->getSpecializedTemplate() && "No variable template?")(static_cast <bool> (VarTemplSpec->getSpecializedTemplate
() && "No variable template?") ? void (0) : __assert_fail
 ("VarTemplSpec->getSpecializedTemplate() && \"No variable template?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 99, __extension__
 __PRETTY_FUNCTION__));
llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
    Specialized = VarTemplSpec->getSpecializedTemplateOrPartial();
if (VarTemplatePartialSpecializationDecl *Partial =
        Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
  if (!SkipForSpecialization)
    Result.addOuterTemplateArguments(
        Partial, VarTemplSpec->getTemplateInstantiationArgs().asArray(),
        /*Final=*/false);
  if (Partial->isMemberSpecialization())
    return Response::Done();
} else {
  VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
  if (!SkipForSpecialization)
    Result.addOuterTemplateArguments(
        Tmpl, VarTemplSpec->getTemplateInstantiationArgs().asArray(),
        /*Final=*/false);
  if (Tmpl->isMemberSpecialization())
    return Response::Done();
}
return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
120}

122// If we have a template template parameter with translation unit context,
123// then we're performing substitution into a default template argument of
124// this template template parameter before we've constructed the template
125// that will own this template template parameter. In this case, we
126// use empty template parameter lists for all of the outer templates
127// to avoid performing any substitutions.
128Response
129HandleDefaultTempArgIntoTempTempParam(const TemplateTemplateParmDecl *TTP,
                                    MultiLevelTemplateArgumentList &Result) {
for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
  Result.addOuterTemplateArguments(std::nullopt);
return Response::Done();
134}

136Response HandlePartialClassTemplateSpec(
  const ClassTemplatePartialSpecializationDecl *PartialClassTemplSpec,
  MultiLevelTemplateArgumentList &Result, bool SkipForSpecialization) {
if (!SkipForSpecialization)
    Result.addOuterRetainedLevels(PartialClassTemplSpec->getTemplateDepth());
return Response::Done();
142}

144// Add template arguments from a class template instantiation.
145Response
146HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
                      MultiLevelTemplateArgumentList &Result,
                      bool SkipForSpecialization) {
if (!ClassTemplSpec->isClassScopeExplicitSpecialization()) {
  // We're done when we hit an explicit specialization.
  if (ClassTemplSpec->getSpecializationKind() == TSK_ExplicitSpecialization &&
      !isa<ClassTemplatePartialSpecializationDecl>(ClassTemplSpec))
    return Response::Done();

  if (!SkipForSpecialization)
    Result.addOuterTemplateArguments(
        const_cast<ClassTemplateSpecializationDecl *>(ClassTemplSpec),
        ClassTemplSpec->getTemplateInstantiationArgs().asArray(),
        /*Final=*/false);

  // If this class template specialization was instantiated from a
  // specialized member that is a class template, we're done.
  assert(ClassTemplSpec->getSpecializedTemplate() && "No class template?")(static_cast <bool> (ClassTemplSpec->getSpecializedTemplate
() && "No class template?") ? void (0) : __assert_fail
 ("ClassTemplSpec->getSpecializedTemplate() && \"No class template?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 163, __extension__
 __PRETTY_FUNCTION__));
  if (ClassTemplSpec->getSpecializedTemplate()->isMemberSpecialization())
    return Response::Done();
}
return Response::UseNextDecl(ClassTemplSpec);
168}

170Response HandleFunction(const FunctionDecl *Function,
                      MultiLevelTemplateArgumentList &Result,
                      const FunctionDecl *Pattern, bool RelativeToPrimary,
                      bool ForConstraintInstantiation) {
// Add template arguments from a function template specialization.
if (!RelativeToPrimary &&
    Function->getTemplateSpecializationKindForInstantiation() ==
        TSK_ExplicitSpecialization)
  return Response::Done();

if (!RelativeToPrimary &&
    Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
  // This is an implicit instantiation of an explicit specialization. We
  // don't get any template arguments from this function but might get
  // some from an enclosing template.
  return Response::UseNextDecl(Function);
} else if (const TemplateArgumentList *TemplateArgs =
               Function->getTemplateSpecializationArgs()) {
  // Add the template arguments for this specialization.
  Result.addOuterTemplateArguments(const_cast<FunctionDecl *>(Function),
                                   TemplateArgs->asArray(),
                                   /*Final=*/false);

  // If this function was instantiated from a specialized member that is
  // a function template, we're done.
  assert(Function->getPrimaryTemplate() && "No function template?")(static_cast <bool> (Function->getPrimaryTemplate() &&
 "No function template?") ? void (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 195, __extension__
 __PRETTY_FUNCTION__));
  if (Function->getPrimaryTemplate()->isMemberSpecialization())
    return Response::Done();

  // If this function is a generic lambda specialization, we are done.
  if (!ForConstraintInstantiation &&
      isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
    return Response::Done();

} else if (Function->getDescribedFunctionTemplate()) {
  assert((static_cast <bool> ((ForConstraintInstantiation || Result
.getNumSubstitutedLevels() == 0) && "Outer template not instantiated?"
) ? void (0) : __assert_fail ("(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) && \"Outer template not instantiated?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 207, __extension__
 __PRETTY_FUNCTION__))
      (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&(static_cast <bool> ((ForConstraintInstantiation || Result
.getNumSubstitutedLevels() == 0) && "Outer template not instantiated?"
) ? void (0) : __assert_fail ("(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) && \"Outer template not instantiated?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 207, __extension__
 __PRETTY_FUNCTION__))
      "Outer template not instantiated?")(static_cast <bool> ((ForConstraintInstantiation || Result
.getNumSubstitutedLevels() == 0) && "Outer template not instantiated?"
) ? void (0) : __assert_fail ("(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) && \"Outer template not instantiated?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 207, __extension__
 __PRETTY_FUNCTION__));
}
// If this is a friend or local declaration and it declares an entity at
// namespace scope, take arguments from its lexical parent
// instead of its semantic parent, unless of course the pattern we're
// instantiating actually comes from the file's context!
if ((Function->getFriendObjectKind() || Function->isLocalExternDecl()) &&
    Function->getNonTransparentDeclContext()->isFileContext() &&
    (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
  return Response::ChangeDecl(Function->getLexicalDeclContext());
}
return Response::UseNextDecl(Function);
219}

221Response HandleFunctionTemplateDecl(const FunctionTemplateDecl *FTD,
                                  MultiLevelTemplateArgumentList &Result) {
if (!isa<ClassTemplateSpecializationDecl>(FTD->getDeclContext())) {
  NestedNameSpecifier *NNS = FTD->getTemplatedDecl()->getQualifier();
  const Type *Ty;
  const TemplateSpecializationType *TSTy;
  if (NNS && (Ty = NNS->getAsType()) &&
      (TSTy = Ty->getAs<TemplateSpecializationType>()))
    Result.addOuterTemplateArguments(const_cast<FunctionTemplateDecl *>(FTD),
                                     TSTy->template_arguments(),
                                     /*Final=*/false);
}
return Response::ChangeDecl(FTD->getLexicalDeclContext());
234}

236Response HandleRecordDecl(const CXXRecordDecl *Rec,
                        MultiLevelTemplateArgumentList &Result,
                        ASTContext &Context,
                        bool ForConstraintInstantiation) {
if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
  assert((static_cast <bool> ((ForConstraintInstantiation || Result
.getNumSubstitutedLevels() == 0) && "Outer template not instantiated?"
) ? void (0) : __assert_fail ("(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) && \"Outer template not instantiated?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 243, __extension__
 __PRETTY_FUNCTION__))
      (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&(static_cast <bool> ((ForConstraintInstantiation || Result
.getNumSubstitutedLevels() == 0) && "Outer template not instantiated?"
) ? void (0) : __assert_fail ("(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) && \"Outer template not instantiated?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 243, __extension__
 __PRETTY_FUNCTION__))
      "Outer template not instantiated?")(static_cast <bool> ((ForConstraintInstantiation || Result
.getNumSubstitutedLevels() == 0) && "Outer template not instantiated?"
) ? void (0) : __assert_fail ("(ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) && \"Outer template not instantiated?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 243, __extension__
 __PRETTY_FUNCTION__));
  if (ClassTemplate->isMemberSpecialization())
    return Response::Done();
  if (ForConstraintInstantiation)
    Result.addOuterTemplateArguments(const_cast<CXXRecordDecl *>(Rec),
                                     ClassTemplate->getInjectedTemplateArgs(),
                                     /*Final=*/false);
}

bool IsFriend = Rec->getFriendObjectKind() ||
                (Rec->getDescribedClassTemplate() &&
                 Rec->getDescribedClassTemplate()->getFriendObjectKind());
if (ForConstraintInstantiation && IsFriend &&
    Rec->getNonTransparentDeclContext()->isFileContext()) {
  return Response::ChangeDecl(Rec->getLexicalDeclContext());
}

// This is to make sure we pick up the VarTemplateSpecializationDecl that this
// lambda is defined inside of.
if (Rec->isLambda())
  if (const Decl *LCD = Rec->getLambdaContextDecl())
    return Response::ChangeDecl(LCD);

return Response::UseNextDecl(Rec);
267}

269Response HandleImplicitConceptSpecializationDecl(
  const ImplicitConceptSpecializationDecl *CSD,
  MultiLevelTemplateArgumentList &Result) {
Result.addOuterTemplateArguments(
    const_cast<ImplicitConceptSpecializationDecl *>(CSD),
    CSD->getTemplateArguments(),
    /*Final=*/false);
return Response::UseNextDecl(CSD);
277}

279Response HandleGenericDeclContext(const Decl *CurDecl) {
return Response::UseNextDecl(CurDecl);
281}
282} // namespace TemplateInstArgsHelpers
283} // namespace

285/// Retrieve the template argument list(s) that should be used to
286/// instantiate the definition of the given declaration.
287///
288/// \param ND the declaration for which we are computing template instantiation
289/// arguments.
290///
291/// \param Innermost if non-NULL, specifies a template argument list for the
292/// template declaration passed as ND.
293///
294/// \param RelativeToPrimary true if we should get the template
295/// arguments relative to the primary template, even when we're
296/// dealing with a specialization. This is only relevant for function
297/// template specializations.
298///
299/// \param Pattern If non-NULL, indicates the pattern from which we will be
300/// instantiating the definition of the given declaration, \p ND. This is
301/// used to determine the proper set of template instantiation arguments for
302/// friend function template specializations.
303///
304/// \param ForConstraintInstantiation when collecting arguments,
305/// ForConstraintInstantiation indicates we should continue looking when
306/// encountering a lambda generic call operator, and continue looking for
307/// arguments on an enclosing class template.

309MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
  const NamedDecl *ND, bool Final, const TemplateArgumentList *Innermost,
  bool RelativeToPrimary, const FunctionDecl *Pattern,
  bool ForConstraintInstantiation, bool SkipForSpecialization) {
assert(ND && "Can't find arguments for a decl if one isn't provided")(static_cast <bool> (ND && "Can't find arguments for a decl if one isn't provided"
) ? void (0) : __assert_fail ("ND && \"Can't find arguments for a decl if one isn't provided\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 313, __extension__
 __PRETTY_FUNCTION__));
// Accumulate the set of template argument lists in this structure.
MultiLevelTemplateArgumentList Result;

using namespace TemplateInstArgsHelpers;
const Decl *CurDecl = ND;
if (Innermost) {
  Result.addOuterTemplateArguments(const_cast<NamedDecl *>(ND),
                                   Innermost->asArray(), Final);
  CurDecl = Response::UseNextDecl(ND).NextDecl;
}

while (!CurDecl->isFileContextDecl()) {
  Response R;
  if (const auto *VarTemplSpec =
          dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
    R = HandleVarTemplateSpec(VarTemplSpec, Result, SkipForSpecialization);
  } else if (const auto *PartialClassTemplSpec =
                 dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
    R = HandlePartialClassTemplateSpec(PartialClassTemplSpec, Result,
                                       SkipForSpecialization);
  } else if (const auto *ClassTemplSpec =
                 dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
    R = HandleClassTemplateSpec(ClassTemplSpec, Result,
                                SkipForSpecialization);
  } else if (const auto *Function = dyn_cast<FunctionDecl>(CurDecl)) {
    R = HandleFunction(Function, Result, Pattern, RelativeToPrimary,
                       ForConstraintInstantiation);
  } else if (const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
    R = HandleRecordDecl(Rec, Result, Context, ForConstraintInstantiation);
  } else if (const auto *CSD =
                 dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
    R = HandleImplicitConceptSpecializationDecl(CSD, Result);
  } else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
    R = HandleFunctionTemplateDecl(FTD, Result);
  } else if (!isa<DeclContext>(CurDecl)) {
    R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
    if (CurDecl->getDeclContext()->isTranslationUnit()) {
      if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {
        R = HandleDefaultTempArgIntoTempTempParam(TTP, Result);
      }
    }
  } else {
    R = HandleGenericDeclContext(CurDecl);
  }

  if (R.IsDone)
    return Result;
  if (R.ClearRelativeToPrimary)
    RelativeToPrimary = false;
  assert(R.NextDecl)(static_cast <bool> (R.NextDecl) ? void (0) : __assert_fail
 ("R.NextDecl", "clang/lib/Sema/SemaTemplateInstantiate.cpp",
 363, __extension__ __PRETTY_FUNCTION__));
  CurDecl = R.NextDecl;
}

return Result;
368}

370bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
switch (Kind) {
case TemplateInstantiation:
case ExceptionSpecInstantiation:
case DefaultTemplateArgumentInstantiation:
case DefaultFunctionArgumentInstantiation:
case ExplicitTemplateArgumentSubstitution:
case DeducedTemplateArgumentSubstitution:
case PriorTemplateArgumentSubstitution:
case ConstraintsCheck:
case NestedRequirementConstraintsCheck:
  return true;

case RequirementInstantiation:
case RequirementParameterInstantiation:
case DefaultTemplateArgumentChecking:
case DeclaringSpecialMember:
case DeclaringImplicitEqualityComparison:
case DefiningSynthesizedFunction:
case ExceptionSpecEvaluation:
case ConstraintSubstitution:
case ParameterMappingSubstitution:
case ConstraintNormalization:
case RewritingOperatorAsSpaceship:
case InitializingStructuredBinding:
case MarkingClassDllexported:
case BuildingBuiltinDumpStructCall:
case LambdaExpressionSubstitution:
  return false;

// This function should never be called when Kind's value is Memoization.
case Memoization:
  break;
}

llvm_unreachable("Invalid SynthesisKind!")::llvm::llvm_unreachable_internal("Invalid SynthesisKind!", "clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 405);
406}

408Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
  SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
  Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo *DeductionInfo)
  : SemaRef(SemaRef) {
// Don't allow further instantiation if a fatal error and an uncompilable
// error have occurred. Any diagnostics we might have raised will not be
// visible, and we do not need to construct a correct AST.
if (SemaRef.Diags.hasFatalErrorOccurred() &&
    SemaRef.hasUncompilableErrorOccurred()) {
  Invalid = true;
  return;
}
Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
if (!Invalid) {
  CodeSynthesisContext Inst;
  Inst.Kind = Kind;
  Inst.PointOfInstantiation = PointOfInstantiation;
  Inst.Entity = Entity;
  Inst.Template = Template;
  Inst.TemplateArgs = TemplateArgs.data();
  Inst.NumTemplateArgs = TemplateArgs.size();
  Inst.DeductionInfo = DeductionInfo;
  Inst.InstantiationRange = InstantiationRange;
  SemaRef.pushCodeSynthesisContext(Inst);

  AlreadyInstantiating = !Inst.Entity ? false :
      !SemaRef.InstantiatingSpecializations
           .insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})
           .second;
  atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
}
441}

443Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(SemaRef,
                          CodeSynthesisContext::TemplateInstantiation,
                          PointOfInstantiation, InstantiationRange, Entity) {}

450Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, FunctionDecl *Entity,
  ExceptionSpecification, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::ExceptionSpecInstantiation,
        PointOfInstantiation, InstantiationRange, Entity) {}

457Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
  TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DefaultTemplateArgumentInstantiation,
        PointOfInstantiation, InstantiationRange, getAsNamedDecl(Param),
        Template, TemplateArgs) {}

467Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  FunctionTemplateDecl *FunctionTemplate,
  ArrayRef<TemplateArgument> TemplateArgs,
  CodeSynthesisContext::SynthesisKind Kind,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
                          InstantiationRange, FunctionTemplate, nullptr,
                          TemplateArgs, &DeductionInfo) {
assert((static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 478, __extension__
 __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 478, __extension__
 __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 478, __extension__
 __PRETTY_FUNCTION__));
479}

481Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  TemplateDecl *Template,
  ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, Template, nullptr,
        TemplateArgs, &DeductionInfo) {}

492Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  ClassTemplatePartialSpecializationDecl *PartialSpec,
  ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
        TemplateArgs, &DeductionInfo) {}

503Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  VarTemplatePartialSpecializationDecl *PartialSpec,
  ArrayRef<TemplateArgument> TemplateArgs,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
        TemplateArgs, &DeductionInfo) {}

514Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
  ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
        PointOfInstantiation, InstantiationRange, Param, nullptr,
        TemplateArgs) {}

523Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
  NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::PriorTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, Param, Template,
        TemplateArgs) {}

533Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
  TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef,
        CodeSynthesisContext::PriorTemplateArgumentSubstitution,
        PointOfInstantiation, InstantiationRange, Param, Template,
        TemplateArgs) {}

543Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
  NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
        PointOfInstantiation, InstantiationRange, Param, Template,
        TemplateArgs) {}

552Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  concepts::Requirement *Req, sema::TemplateDeductionInfo &DeductionInfo,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::RequirementInstantiation,
        PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
        /*Template=*/nullptr, /*TemplateArgs=*/std::nullopt, &DeductionInfo) {
560}

562Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  concepts::NestedRequirement *Req, ConstraintsCheck,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::NestedRequirementConstraintsCheck,
        PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
        /*Template=*/nullptr, /*TemplateArgs=*/std::nullopt) {}

571Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation, const RequiresExpr *RE,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::RequirementParameterInstantiation,
        PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
        /*Template=*/nullptr, /*TemplateArgs=*/std::nullopt, &DeductionInfo) {
578}

580Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  ConstraintsCheck, NamedDecl *Template,
  ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::ConstraintsCheck,
        PointOfInstantiation, InstantiationRange, Template, nullptr,
        TemplateArgs) {}

589Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  ConstraintSubstitution, NamedDecl *Template,
  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::ConstraintSubstitution,
        PointOfInstantiation, InstantiationRange, Template, nullptr,
        {}, &DeductionInfo) {}

598Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  ConstraintNormalization, NamedDecl *Template,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::ConstraintNormalization,
        PointOfInstantiation, InstantiationRange, Template) {}

606Sema::InstantiatingTemplate::InstantiatingTemplate(
  Sema &SemaRef, SourceLocation PointOfInstantiation,
  ParameterMappingSubstitution, NamedDecl *Template,
  SourceRange InstantiationRange)
  : InstantiatingTemplate(
        SemaRef, CodeSynthesisContext::ParameterMappingSubstitution,
        PointOfInstantiation, InstantiationRange, Template) {}


615void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
InNonInstantiationSFINAEContext = false;

CodeSynthesisContexts.push_back(Ctx);

if (!Ctx.isInstantiationRecord())
  ++NonInstantiationEntries;

// Check to see if we're low on stack space. We can't do anything about this
// from here, but we can at least warn the user.
if (isStackNearlyExhausted())
  warnStackExhausted(Ctx.PointOfInstantiation);
628}

630void Sema::popCodeSynthesisContext() {
auto &Active = CodeSynthesisContexts.back();
if (!Active.isInstantiationRecord()) {
  assert(NonInstantiationEntries > 0)(static_cast <bool> (NonInstantiationEntries > 0) ? void
 (0) : __assert_fail ("NonInstantiationEntries > 0", "clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 633, __extension__ __PRETTY_FUNCTION__));
  --NonInstantiationEntries;
}

InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;

// Name lookup no longer looks in this template's defining module.
assert(CodeSynthesisContexts.size() >=(static_cast <bool> (CodeSynthesisContexts.size() >=
 CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 642, __extension__
 __PRETTY_FUNCTION__))
           CodeSynthesisContextLookupModules.size() &&(static_cast <bool> (CodeSynthesisContexts.size() >=
 CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 642, __extension__
 __PRETTY_FUNCTION__))
       "forgot to remove a lookup module for a template instantiation")(static_cast <bool> (CodeSynthesisContexts.size() >=
 CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 642, __extension__
 __PRETTY_FUNCTION__));
if (CodeSynthesisContexts.size() ==
    CodeSynthesisContextLookupModules.size()) {
  if (Module *M = CodeSynthesisContextLookupModules.back())
    LookupModulesCache.erase(M);
  CodeSynthesisContextLookupModules.pop_back();
}

// If we've left the code synthesis context for the current context stack,
// stop remembering that we've emitted that stack.
if (CodeSynthesisContexts.size() ==
    LastEmittedCodeSynthesisContextDepth)
  LastEmittedCodeSynthesisContextDepth = 0;

CodeSynthesisContexts.pop_back();
657}

659void Sema::InstantiatingTemplate::Clear() {
if (!Invalid) {
  if (!AlreadyInstantiating) {
    auto &Active = SemaRef.CodeSynthesisContexts.back();
    if (Active.Entity)
      SemaRef.InstantiatingSpecializations.erase(
          {Active.Entity->getCanonicalDecl(), Active.Kind});
  }

  atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
                SemaRef.CodeSynthesisContexts.back());

  SemaRef.popCodeSynthesisContext();
  Invalid = true;
}
674}

676static std::string convertCallArgsToString(Sema &S,
                                         llvm::ArrayRef<const Expr *> Args) {
std::string Result;
llvm::raw_string_ostream OS(Result);
llvm::ListSeparator Comma;
for (const Expr *Arg : Args) {
  OS << Comma;
  Arg->IgnoreParens()->printPretty(OS, nullptr,
                                   S.Context.getPrintingPolicy());
}
return Result;
687}

689bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
                                      SourceLocation PointOfInstantiation,
                                         SourceRange InstantiationRange) {
assert(SemaRef.NonInstantiationEntries <=(static_cast <bool> (SemaRef.NonInstantiationEntries <=
 SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
 ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 693, __extension__
 __PRETTY_FUNCTION__))
       SemaRef.CodeSynthesisContexts.size())(static_cast <bool> (SemaRef.NonInstantiationEntries <=
 SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
 ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 693, __extension__
 __PRETTY_FUNCTION__));
if ((SemaRef.CodeSynthesisContexts.size() -
        SemaRef.NonInstantiationEntries)
      <= SemaRef.getLangOpts().InstantiationDepth)
  return false;

SemaRef.Diag(PointOfInstantiation,
             diag::err_template_recursion_depth_exceeded)
  << SemaRef.getLangOpts().InstantiationDepth
  << InstantiationRange;
SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
  << SemaRef.getLangOpts().InstantiationDepth;
return true;
706}

708/// Prints the current instantiation stack through a series of
709/// notes.
710void Sema::PrintInstantiationStack() {
// Determine which template instantiations to skip, if any.
unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
unsigned Limit = Diags.getTemplateBacktraceLimit();
if (Limit && Limit < CodeSynthesisContexts.size()) {
  SkipStart = Limit / 2 + Limit % 2;
  SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
}

// FIXME: In all of these cases, we need to show the template arguments
unsigned InstantiationIdx = 0;
for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
       Active = CodeSynthesisContexts.rbegin(),
       ActiveEnd = CodeSynthesisContexts.rend();
     Active != ActiveEnd;
     ++Active, ++InstantiationIdx) {
  // Skip this instantiation?
  if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
    if (InstantiationIdx == SkipStart) {
      // Note that we're skipping instantiations.
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_instantiation_contexts_suppressed)
        << unsigned(CodeSynthesisContexts.size() - Limit);
    }
    continue;
  }

  switch (Active->Kind) {
  case CodeSynthesisContext::TemplateInstantiation: {
    Decl *D = Active->Entity;
    if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
      unsigned DiagID = diag::note_template_member_class_here;
      if (isa<ClassTemplateSpecializationDecl>(Record))
        DiagID = diag::note_template_class_instantiation_here;
      Diags.Report(Active->PointOfInstantiation, DiagID)
        << Record << Active->InstantiationRange;
    } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
      unsigned DiagID;
      if (Function->getPrimaryTemplate())
        DiagID = diag::note_function_template_spec_here;
      else
        DiagID = diag::note_template_member_function_here;
      Diags.Report(Active->PointOfInstantiation, DiagID)
        << Function
        << Active->InstantiationRange;
    } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
      Diags.Report(Active->PointOfInstantiation,
                   VD->isStaticDataMember()?
                     diag::note_template_static_data_member_def_here
                   : diag::note_template_variable_def_here)
        << VD
        << Active->InstantiationRange;
    } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_template_enum_def_here)
        << ED
        << Active->InstantiationRange;
    } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_template_nsdmi_here)
          << FD << Active->InstantiationRange;
    } else {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_template_type_alias_instantiation_here)
        << cast<TypeAliasTemplateDecl>(D)
        << Active->InstantiationRange;
    }
    break;
  }

  case CodeSynthesisContext::DefaultTemplateArgumentInstantiation: {
    TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
    SmallString<128> TemplateArgsStr;
    llvm::raw_svector_ostream OS(TemplateArgsStr);
    Template->printName(OS, getPrintingPolicy());
    printTemplateArgumentList(OS, Active->template_arguments(),
                              getPrintingPolicy());
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_default_arg_instantiation_here)
      << OS.str()
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: {
    FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_explicit_template_arg_substitution_here)
      << FnTmpl
      << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
                                         Active->TemplateArgs,
                                         Active->NumTemplateArgs)
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: {
    if (FunctionTemplateDecl *FnTmpl =
            dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_function_template_deduction_instantiation_here)
        << FnTmpl
        << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
                                           Active->TemplateArgs,
                                           Active->NumTemplateArgs)
        << Active->InstantiationRange;
    } else {
      bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
                   isa<VarTemplateSpecializationDecl>(Active->Entity);
      bool IsTemplate = false;
      TemplateParameterList *Params;
      if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
        IsTemplate = true;
        Params = D->getTemplateParameters();
      } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
                     Active->Entity)) {
        Params = D->getTemplateParameters();
      } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
                     Active->Entity)) {
        Params = D->getTemplateParameters();
      } else {
        llvm_unreachable("unexpected template kind")::llvm::llvm_unreachable_internal("unexpected template kind",
 "clang/lib/Sema/SemaTemplateInstantiate.cpp", 831);
      }

      Diags.Report(Active->PointOfInstantiation,
                   diag::note_deduced_template_arg_substitution_here)
        << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
        << getTemplateArgumentBindingsText(Params, Active->TemplateArgs,
                                           Active->NumTemplateArgs)
        << Active->InstantiationRange;
    }
    break;
  }

  case CodeSynthesisContext::DefaultFunctionArgumentInstantiation: {
    ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
    FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());

    SmallString<128> TemplateArgsStr;
    llvm::raw_svector_ostream OS(TemplateArgsStr);
    FD->printName(OS, getPrintingPolicy());
    printTemplateArgumentList(OS, Active->template_arguments(),
                              getPrintingPolicy());
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_default_function_arg_instantiation_here)
      << OS.str()
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::PriorTemplateArgumentSubstitution: {
    NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
    std::string Name;
    if (!Parm->getName().empty())
      Name = std::string(" '") + Parm->getName().str() + "'";

    TemplateParameterList *TemplateParams = nullptr;
    if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
      TemplateParams = Template->getTemplateParameters();
    else
      TemplateParams =
        cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
                                                    ->getTemplateParameters();
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_prior_template_arg_substitution)
      << isa<TemplateTemplateParmDecl>(Parm)
      << Name
      << getTemplateArgumentBindingsText(TemplateParams,
                                         Active->TemplateArgs,
                                         Active->NumTemplateArgs)
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::DefaultTemplateArgumentChecking: {
    TemplateParameterList *TemplateParams = nullptr;
    if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
      TemplateParams = Template->getTemplateParameters();
    else
      TemplateParams =
        cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
                                                    ->getTemplateParameters();

    Diags.Report(Active->PointOfInstantiation,
                 diag::note_template_default_arg_checking)
      << getTemplateArgumentBindingsText(TemplateParams,
                                         Active->TemplateArgs,
                                         Active->NumTemplateArgs)
      << Active->InstantiationRange;
    break;
  }

  case CodeSynthesisContext::ExceptionSpecEvaluation:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_evaluating_exception_spec_here)
        << cast<FunctionDecl>(Active->Entity);
    break;

  case CodeSynthesisContext::ExceptionSpecInstantiation:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_template_exception_spec_instantiation_here)
      << cast<FunctionDecl>(Active->Entity)
      << Active->InstantiationRange;
    break;

  case CodeSynthesisContext::RequirementInstantiation:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_template_requirement_instantiation_here)
      << Active->InstantiationRange;
    break;
  case CodeSynthesisContext::RequirementParameterInstantiation:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_template_requirement_params_instantiation_here)
        << Active->InstantiationRange;
    break;

  case CodeSynthesisContext::NestedRequirementConstraintsCheck:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_nested_requirement_here)
      << Active->InstantiationRange;
    break;

  case CodeSynthesisContext::DeclaringSpecialMember:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_in_declaration_of_implicit_special_member)
      << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
    break;

  case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
    Diags.Report(Active->Entity->getLocation(),
                 diag::note_in_declaration_of_implicit_equality_comparison);
    break;

  case CodeSynthesisContext::DefiningSynthesizedFunction: {
    // FIXME: For synthesized functions that are not defaulted,
    // produce a note.
    auto *FD = dyn_cast<FunctionDecl>(Active->Entity);
    DefaultedFunctionKind DFK =
        FD ? getDefaultedFunctionKind(FD) : DefaultedFunctionKind();
    if (DFK.isSpecialMember()) {
      auto *MD = cast<CXXMethodDecl>(FD);
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_member_synthesized_at)
          << MD->isExplicitlyDefaulted() << DFK.asSpecialMember()
          << Context.getTagDeclType(MD->getParent());
    } else if (DFK.isComparison()) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_comparison_synthesized_at)
          << (int)DFK.asComparison()
          << Context.getTagDeclType(
                 cast<CXXRecordDecl>(FD->getLexicalDeclContext()));
    }
    break;
  }

  case CodeSynthesisContext::RewritingOperatorAsSpaceship:
    Diags.Report(Active->Entity->getLocation(),
                 diag::note_rewriting_operator_as_spaceship);
    break;

  case CodeSynthesisContext::InitializingStructuredBinding:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_in_binding_decl_init)
        << cast<BindingDecl>(Active->Entity);
    break;

  case CodeSynthesisContext::MarkingClassDllexported:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_due_to_dllexported_class)
        << cast<CXXRecordDecl>(Active->Entity) << !getLangOpts().CPlusPlus11;
    break;

  case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_building_builtin_dump_struct_call)
        << convertCallArgsToString(
               *this, llvm::ArrayRef(Active->CallArgs, Active->NumCallArgs));
    break;

  case CodeSynthesisContext::Memoization:
    break;

  case CodeSynthesisContext::LambdaExpressionSubstitution:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_lambda_substitution_here);
    break;
  case CodeSynthesisContext::ConstraintsCheck: {
    unsigned DiagID = 0;
    if (!Active->Entity) {
      Diags.Report(Active->PointOfInstantiation,
                   diag::note_nested_requirement_here)
        << Active->InstantiationRange;
      break;
    }
    if (isa<ConceptDecl>(Active->Entity))
      DiagID = diag::note_concept_specialization_here;
    else if (isa<TemplateDecl>(Active->Entity))
      DiagID = diag::note_checking_constraints_for_template_id_here;
    else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))
      DiagID = diag::note_checking_constraints_for_var_spec_id_here;
    else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))
      DiagID = diag::note_checking_constraints_for_class_spec_id_here;
    else {
      assert(isa<FunctionDecl>(Active->Entity))(static_cast <bool> (isa<FunctionDecl>(Active->
Entity)) ? void (0) : __assert_fail ("isa<FunctionDecl>(Active->Entity)"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1013, __extension__
 __PRETTY_FUNCTION__));
      DiagID = diag::note_checking_constraints_for_function_here;
    }
    SmallString<128> TemplateArgsStr;
    llvm::raw_svector_ostream OS(TemplateArgsStr);
    cast<NamedDecl>(Active->Entity)->printName(OS, getPrintingPolicy());
    if (!isa<FunctionDecl>(Active->Entity)) {
      printTemplateArgumentList(OS, Active->template_arguments(),
                                getPrintingPolicy());
    }
    Diags.Report(Active->PointOfInstantiation, DiagID) << OS.str()
      << Active->InstantiationRange;
    break;
  }
  case CodeSynthesisContext::ConstraintSubstitution:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_constraint_substitution_here)
        << Active->InstantiationRange;
    break;
  case CodeSynthesisContext::ConstraintNormalization:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_constraint_normalization_here)
        << cast<NamedDecl>(Active->Entity)->getName()
        << Active->InstantiationRange;
    break;
  case CodeSynthesisContext::ParameterMappingSubstitution:
    Diags.Report(Active->PointOfInstantiation,
                 diag::note_parameter_mapping_substitution_here)
        << Active->InstantiationRange;
    break;
  }
}
1045}

1047std::optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
if (InNonInstantiationSFINAEContext)
  return std::optional<TemplateDeductionInfo *>(nullptr);

bool SawLambdaSubstitution = false;
for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
       Active = CodeSynthesisContexts.rbegin(),
       ActiveEnd = CodeSynthesisContexts.rend();
     Active != ActiveEnd;
     ++Active)
{
  switch (Active->Kind) {
  case CodeSynthesisContext::TemplateInstantiation:
    // An instantiation of an alias template may or may not be a SFINAE
    // context, depending on what else is on the stack.
    if (isa<TypeAliasTemplateDecl>(Active->Entity))
      break;
    [[fallthrough]];
  case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
  case CodeSynthesisContext::ExceptionSpecInstantiation:
  case CodeSynthesisContext::ConstraintsCheck:
  case CodeSynthesisContext::ParameterMappingSubstitution:
  case CodeSynthesisContext::ConstraintNormalization:
  case CodeSynthesisContext::NestedRequirementConstraintsCheck:
    // This is a template instantiation, so there is no SFINAE.
    return std::nullopt;
  case CodeSynthesisContext::LambdaExpressionSubstitution:
    // [temp.deduct]p9
    // A lambda-expression appearing in a function type or a template
    // parameter is not considered part of the immediate context for the
    // purposes of template argument deduction.

    // We need to check parents.
    SawLambdaSubstitution = true;
    break;

  case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
  case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
  case CodeSynthesisContext::DefaultTemplateArgumentChecking:
  case CodeSynthesisContext::RewritingOperatorAsSpaceship:
    // A default template argument instantiation and substitution into
    // template parameters with arguments for prior parameters may or may
    // not be a SFINAE context; look further up the stack.
    break;

  case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
  case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
    // We're either substituting explicitly-specified template arguments,
    // deduced template arguments. SFINAE applies unless we are in a lambda
    // expression, see [temp.deduct]p9.
    if (SawLambdaSubstitution)
      return std::nullopt;
    [[fallthrough]];
  case CodeSynthesisContext::ConstraintSubstitution:
  case CodeSynthesisContext::RequirementInstantiation:
  case CodeSynthesisContext::RequirementParameterInstantiation:
    // SFINAE always applies in a constraint expression or a requirement
    // in a requires expression.
    assert(Active->DeductionInfo && "Missing deduction info pointer")(static_cast <bool> (Active->DeductionInfo &&
 "Missing deduction info pointer") ? void (0) : __assert_fail
 ("Active->DeductionInfo && \"Missing deduction info pointer\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1105, __extension__
 __PRETTY_FUNCTION__));
    return Active->DeductionInfo;

  case CodeSynthesisContext::DeclaringSpecialMember:
  case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
  case CodeSynthesisContext::DefiningSynthesizedFunction:
  case CodeSynthesisContext::InitializingStructuredBinding:
  case CodeSynthesisContext::MarkingClassDllexported:
  case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
    // This happens in a context unrelated to template instantiation, so
    // there is no SFINAE.
    return std::nullopt;

  case CodeSynthesisContext::ExceptionSpecEvaluation:
    // FIXME: This should not be treated as a SFINAE context, because
    // we will cache an incorrect exception specification. However, clang
    // bootstrap relies this! See PR31692.
    break;

  case CodeSynthesisContext::Memoization:
    break;
  }

  // The inner context was transparent for SFINAE. If it occurred within a
  // non-instantiation SFINAE context, then SFINAE applies.
  if (Active->SavedInNonInstantiationSFINAEContext)
    return std::optional<TemplateDeductionInfo *>(nullptr);
}

return std::nullopt;
1135}

1137//===----------------------------------------------------------------------===/
1138// Template Instantiation for Types
1139//===----------------------------------------------------------------------===/
1140namespace {
class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
  const MultiLevelTemplateArgumentList &TemplateArgs;
  SourceLocation Loc;
  DeclarationName Entity;
  bool EvaluateConstraints = true;

public:
  typedef TreeTransform<TemplateInstantiator> inherited;

  TemplateInstantiator(Sema &SemaRef,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SourceLocation Loc, DeclarationName Entity)
      : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
        Entity(Entity) {}

  void setEvaluateConstraints(bool B) {
    EvaluateConstraints = B;
  }
  bool getEvaluateConstraints() {
    return EvaluateConstraints;
  }

  /// Determine whether the given type \p T has already been
  /// transformed.
  ///
  /// For the purposes of template instantiation, a type has already been
  /// transformed if it is NULL or if it is not dependent.
  bool AlreadyTransformed(QualType T);

  /// Returns the location of the entity being instantiated, if known.
  SourceLocation getBaseLocation() { return Loc; }

  /// Returns the name of the entity being instantiated, if any.
  DeclarationName getBaseEntity() { return Entity; }

  /// Sets the "base" location and entity when that
  /// information is known based on another transformation.
  void setBase(SourceLocation Loc, DeclarationName Entity) {
    this->Loc = Loc;
    this->Entity = Entity;
  }

  unsigned TransformTemplateDepth(unsigned Depth) {
    return TemplateArgs.getNewDepth(Depth);
  }

  std::optional<unsigned> getPackIndex(TemplateArgument Pack) {
    int Index = getSema().ArgumentPackSubstitutionIndex;
    if (Index == -1)
      return std::nullopt;
    return Pack.pack_size() - 1 - Index;
  }

  bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
                               SourceRange PatternRange,
                               ArrayRef<UnexpandedParameterPack> Unexpanded,
                               bool &ShouldExpand, bool &RetainExpansion,
                               std::optional<unsigned> &NumExpansions) {
    return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
                                                     PatternRange, Unexpanded,
                                                     TemplateArgs,
                                                     ShouldExpand,
                                                     RetainExpansion,
                                                     NumExpansions);
  }

  void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
    SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack);
  }

  TemplateArgument ForgetPartiallySubstitutedPack() {
    TemplateArgument Result;
    if (NamedDecl *PartialPack
          = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
      MultiLevelTemplateArgumentList &TemplateArgs
        = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
      unsigned Depth, Index;
      std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
      if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
        Result = TemplateArgs(Depth, Index);
        TemplateArgs.setArgument(Depth, Index, TemplateArgument());
      }
    }

    return Result;
  }

  void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
    if (Arg.isNull())
      return;

    if (NamedDecl *PartialPack
          = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
      MultiLevelTemplateArgumentList &TemplateArgs
      = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
      unsigned Depth, Index;
      std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
      TemplateArgs.setArgument(Depth, Index, Arg);
    }
  }

  /// Transform the given declaration by instantiating a reference to
  /// this declaration.
  Decl *TransformDecl(SourceLocation Loc, Decl *D);

  void transformAttrs(Decl *Old, Decl *New) {
    SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
  }

  void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> NewDecls) {
    if (Old->isParameterPack()) {
16
←
Assuming the condition is false→
      SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Old);
      for (auto *New : NewDecls)
        SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(
            Old, cast<VarDecl>(New));
      return;
    }

    assert(NewDecls.size() == 1 &&(static_cast <bool> (NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? void (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1260, __extension__
 __PRETTY_FUNCTION__))
17
←
Taking false branch→
18
←
Assuming the condition is true→
19
←
'?' condition is true→
           "should only have multiple expansions for a pack")(static_cast <bool> (NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? void (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1260, __extension__
 __PRETTY_FUNCTION__));
    Decl *New = NewDecls.front();

    // If we've instantiated the call operator of a lambda or the call
    // operator template of a generic lambda, update the "instantiation of"
    // information.
    auto *NewMD = dyn_cast<CXXMethodDecl>(New);
20
←
Assuming 'New' is a 'CastReturnType'→
    if (NewMD20.1
'NewMD' is non-null
1
'NewMD' is non-null
 && isLambdaCallOperator(NewMD)) {
21
←
Taking true branch→
      auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
22
←
Assuming 'Old' is not a 'CastReturnType'→
23
←
'OldMD' initialized to a null pointer value→
      if (auto *NewTD = NewMD->getDescribedFunctionTemplate())
24
←
Assuming 'NewTD' is non-null→
25
←
Taking true branch→
        NewTD->setInstantiatedFromMemberTemplate(
            OldMD->getDescribedFunctionTemplate());
26
←
Called C++ object pointer is null
      else
        NewMD->setInstantiationOfMemberFunction(OldMD,
                                                TSK_ImplicitInstantiation);
    }

    SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);

    // We recreated a local declaration, but not by instantiating it. There
    // may be pending dependent diagnostics to produce.
    if (auto *DC = dyn_cast<DeclContext>(Old);
        DC && DC->isDependentContext() && DC->isFunctionOrMethod())
      SemaRef.PerformDependentDiagnostics(DC, TemplateArgs);
  }

  /// Transform the definition of the given declaration by
  /// instantiating it.
  Decl *TransformDefinition(SourceLocation Loc, Decl *D);

  /// Transform the first qualifier within a scope by instantiating the
  /// declaration.
  NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);

  /// Rebuild the exception declaration and register the declaration
  /// as an instantiated local.
  VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
                                TypeSourceInfo *Declarator,
                                SourceLocation StartLoc,
                                SourceLocation NameLoc,
                                IdentifierInfo *Name);

  /// Rebuild the Objective-C exception declaration and register the
  /// declaration as an instantiated local.
  VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
                                    TypeSourceInfo *TSInfo, QualType T);

  /// Check for tag mismatches when instantiating an
  /// elaborated type.
  QualType RebuildElaboratedType(SourceLocation KeywordLoc,
                                 ElaboratedTypeKeyword Keyword,
                                 NestedNameSpecifierLoc QualifierLoc,
                                 QualType T);

  TemplateName
  TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
                        SourceLocation NameLoc,
                        QualType ObjectType = QualType(),
                        NamedDecl *FirstQualifierInScope = nullptr,
                        bool AllowInjectedClassName = false);

  const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH);
  const NoInlineAttr *TransformStmtNoInlineAttr(const Stmt *OrigS,
                                                const Stmt *InstS,
                                                const NoInlineAttr *A);
  const AlwaysInlineAttr *
  TransformStmtAlwaysInlineAttr(const Stmt *OrigS, const Stmt *InstS,
                                const AlwaysInlineAttr *A);

  ExprResult TransformPredefinedExpr(PredefinedExpr *E);
  ExprResult TransformDeclRefExpr(DeclRefExpr *E);
  ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);

  ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
                                          NonTypeTemplateParmDecl *D);
  ExprResult TransformSubstNonTypeTemplateParmPackExpr(
                                         SubstNonTypeTemplateParmPackExpr *E);
  ExprResult TransformSubstNonTypeTemplateParmExpr(
                                         SubstNonTypeTemplateParmExpr *E);

  /// Rebuild a DeclRefExpr for a VarDecl reference.
  ExprResult RebuildVarDeclRefExpr(VarDecl *PD, SourceLocation Loc);

  /// Transform a reference to a function or init-capture parameter pack.
  ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E, VarDecl *PD);

  /// Transform a FunctionParmPackExpr which was built when we couldn't
  /// expand a function parameter pack reference which refers to an expanded
  /// pack.
  ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E);

  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
                                      FunctionProtoTypeLoc TL) {
    // Call the base version; it will forward to our overridden version below.
    return inherited::TransformFunctionProtoType(TLB, TL);
  }

  template<typename Fn>
  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
                                      FunctionProtoTypeLoc TL,
                                      CXXRecordDecl *ThisContext,
                                      Qualifiers ThisTypeQuals,
                                      Fn TransformExceptionSpec);

  ParmVarDecl *
  TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment,
                             std::optional<unsigned> NumExpansions,
                             bool ExpectParameterPack);

  using inherited::TransformTemplateTypeParmType;
  /// Transforms a template type parameter type by performing
  /// substitution of the corresponding template type argument.
  QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                         TemplateTypeParmTypeLoc TL,
                                         bool SuppressObjCLifetime);

  QualType BuildSubstTemplateTypeParmType(
      TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final,
      Decl *AssociatedDecl, unsigned Index, std::optional<unsigned> PackIndex,
      TemplateArgument Arg, SourceLocation NameLoc);

  /// Transforms an already-substituted template type parameter pack
  /// into either itself (if we aren't substituting into its pack expansion)
  /// or the appropriate substituted argument.
  using inherited::TransformSubstTemplateTypeParmPackType;
  QualType
  TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                         SubstTemplateTypeParmPackTypeLoc TL,
                                         bool SuppressObjCLifetime);

  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
    Sema::ConstraintEvalRAII<TemplateInstantiator> RAII(*this);

    Sema::CodeSynthesisContext C;
    C.Kind = clang::Sema::CodeSynthesisContext::LambdaExpressionSubstitution;
    C.PointOfInstantiation = E->getBeginLoc();
    SemaRef.pushCodeSynthesisContext(C);
    auto PopCtx =
        llvm::make_scope_exit([this] { SemaRef.popCodeSynthesisContext(); });

    ExprResult Result = inherited::TransformLambdaExpr(E);
1
Calling 'TreeTransform::TransformLambdaExpr'→
    if (Result.isInvalid())
      return Result;

    CXXMethodDecl *MD = Result.getAs<LambdaExpr>()->getCallOperator();
    for (ParmVarDecl *PVD : MD->parameters()) {
      assert(PVD && "null in a parameter list")(static_cast <bool> (PVD && "null in a parameter list"
) ? void (0) : __assert_fail ("PVD && \"null in a parameter list\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1407, __extension__
 __PRETTY_FUNCTION__));
      if (!PVD->hasDefaultArg())
        continue;
      Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
      // FIXME: Obtain the source location for the '=' token.
      SourceLocation EqualLoc = UninstExpr->getBeginLoc();
      if (SemaRef.SubstDefaultArgument(EqualLoc, 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.
        ExprResult ErrorResult = SemaRef.CreateRecoveryExpr(
            UninstExpr->getBeginLoc(), UninstExpr->getEndLoc(),
            { UninstExpr }, UninstExpr->getType());
        if (ErrorResult.isUsable())
          PVD->setDefaultArg(ErrorResult.get());
      }
    }

    return Result;
  }

  ExprResult TransformRequiresExpr(RequiresExpr *E) {
    LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
    ExprResult TransReq = inherited::TransformRequiresExpr(E);
    if (TransReq.isInvalid())
      return TransReq;
    assert(TransReq.get() != E &&(static_cast <bool> (TransReq.get() != E && "Do not change value of isSatisfied for the existing expression. "
 "Create a new expression instead.") ? void (0) : __assert_fail
 ("TransReq.get() != E && \"Do not change value of isSatisfied for the existing expression. \" \"Create a new expression instead.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1435, __extension__
 __PRETTY_FUNCTION__))
           "Do not change value of isSatisfied for the existing expression. "(static_cast <bool> (TransReq.get() != E && "Do not change value of isSatisfied for the existing expression. "
 "Create a new expression instead.") ? void (0) : __assert_fail
 ("TransReq.get() != E && \"Do not change value of isSatisfied for the existing expression. \" \"Create a new expression instead.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1435, __extension__
 __PRETTY_FUNCTION__))
           "Create a new expression instead.")(static_cast <bool> (TransReq.get() != E && "Do not change value of isSatisfied for the existing expression. "
 "Create a new expression instead.") ? void (0) : __assert_fail
 ("TransReq.get() != E && \"Do not change value of isSatisfied for the existing expression. \" \"Create a new expression instead.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1435, __extension__
 __PRETTY_FUNCTION__));
    if (E->getBody()->isDependentContext()) {
      Sema::SFINAETrap Trap(SemaRef);
      // We recreate the RequiresExpr body, but not by instantiating it.
      // Produce pending diagnostics for dependent access check.
      SemaRef.PerformDependentDiagnostics(E->getBody(), TemplateArgs);
      // FIXME: Store SFINAE diagnostics in RequiresExpr for diagnosis.
      if (Trap.hasErrorOccurred())
        TransReq.getAs<RequiresExpr>()->setSatisfied(false);
    }
    return TransReq;
  }

  bool TransformRequiresExprRequirements(
      ArrayRef<concepts::Requirement *> Reqs,
      SmallVectorImpl<concepts::Requirement *> &Transformed) {
    bool SatisfactionDetermined = false;
    for (concepts::Requirement *Req : Reqs) {
      concepts::Requirement *TransReq = nullptr;
      if (!SatisfactionDetermined) {
        if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
          TransReq = TransformTypeRequirement(TypeReq);
        else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
          TransReq = TransformExprRequirement(ExprReq);
        else
          TransReq = TransformNestedRequirement(
              cast<concepts::NestedRequirement>(Req));
        if (!TransReq)
          return true;
        if (!TransReq->isDependent() && !TransReq->isSatisfied())
          // [expr.prim.req]p6
          //   [...]  The substitution and semantic constraint checking
          //   proceeds in lexical order and stops when a condition that
          //   determines the result of the requires-expression is
          //   encountered. [..]
          SatisfactionDetermined = true;
      } else
        TransReq = Req;
      Transformed.push_back(TransReq);
    }
    return false;
  }

  TemplateParameterList *TransformTemplateParameterList(
                            TemplateParameterList *OrigTPL)  {
    if (!OrigTPL || !OrigTPL->size()) return OrigTPL;

    DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
    TemplateDeclInstantiator  DeclInstantiator(getSema(),
                      /* DeclContext *Owner */ Owner, TemplateArgs);
    DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
    return DeclInstantiator.SubstTemplateParams(OrigTPL);
  }

  concepts::TypeRequirement *
  TransformTypeRequirement(concepts::TypeRequirement *Req);
  concepts::ExprRequirement *
  TransformExprRequirement(concepts::ExprRequirement *Req);
  concepts::NestedRequirement *
  TransformNestedRequirement(concepts::NestedRequirement *Req);
  ExprResult TransformRequiresTypeParams(
      SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE,
      RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params,
      SmallVectorImpl<QualType> &PTypes,
      SmallVectorImpl<ParmVarDecl *> &TransParams,
      Sema::ExtParameterInfoBuilder &PInfos);

private:
  ExprResult
  transformNonTypeTemplateParmRef(Decl *AssociatedDecl,
                                  const NonTypeTemplateParmDecl *parm,
                                  SourceLocation loc, TemplateArgument arg,
                                  std::optional<unsigned> PackIndex);
};
1509}

1511bool TemplateInstantiator::AlreadyTransformed(QualType T) {
if (T.isNull())
  return true;

if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
  return false;

getSema().MarkDeclarationsReferencedInType(Loc, T);
return true;
1520}

1522static TemplateArgument
1523getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
assert(S.ArgumentPackSubstitutionIndex >= 0)(static_cast <bool> (S.ArgumentPackSubstitutionIndex >=
 0) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1524, __extension__
 __PRETTY_FUNCTION__));
assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())(static_cast <bool> (S.ArgumentPackSubstitutionIndex <
 (int)Arg.pack_size()) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1525, __extension__
 __PRETTY_FUNCTION__));
Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex];
if (Arg.isPackExpansion())
  Arg = Arg.getPackExpansionPattern();
return Arg;
1530}

1532Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
if (!D)
  return nullptr;

if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
    // If the corresponding template argument is NULL or non-existent, it's
    // because we are performing instantiation from explicitly-specified
    // template arguments in a function template, but there were some
    // arguments left unspecified.
    if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
                                          TTP->getPosition()))
      return D;

    TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());

    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1550, __extension__
 __PRETTY_FUNCTION__))
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1550, __extension__
 __PRETTY_FUNCTION__));
      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && Template.getAsTemplateDecl() &&(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1556, __extension__
 __PRETTY_FUNCTION__))
           "Wrong kind of template template argument")(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1556, __extension__
 __PRETTY_FUNCTION__));
    return Template.getAsTemplateDecl();
  }

  // Fall through to find the instantiated declaration for this template
  // template parameter.
}

return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
1565}

1567Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
if (!Inst)
  return nullptr;

getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
return Inst;
1574}

1576NamedDecl *
1577TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
                                                   SourceLocation Loc) {
// If the first part of the nested-name-specifier was a template type
// parameter, instantiate that type parameter down to a tag type.
if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
  const TemplateTypeParmType *TTP
    = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));

  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
    // FIXME: This needs testing w/ member access expressions.
    TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());

    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1591, __extension__
 __PRETTY_FUNCTION__))
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1591, __extension__
 __PRETTY_FUNCTION__));

      if (getSema().ArgumentPackSubstitutionIndex == -1)
        return nullptr;

      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    QualType T = Arg.getAsType();
    if (T.isNull())
      return cast_or_null<NamedDecl>(TransformDecl(Loc, D));

    if (const TagType *Tag = T->getAs<TagType>())
      return Tag->getDecl();

    // The resulting type is not a tag; complain.
    getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
    return nullptr;
  }
}

return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1613}

1615VarDecl *
1616TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
                                         TypeSourceInfo *Declarator,
                                         SourceLocation StartLoc,
                                         SourceLocation NameLoc,
                                         IdentifierInfo *Name) {
VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
                                               StartLoc, NameLoc, Name);
if (Var)
  getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
return Var;
1626}

1628VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
                                                      TypeSourceInfo *TSInfo,
                                                      QualType T) {
VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
if (Var)
  getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
return Var;
1635}

1637QualType
1638TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
                                          ElaboratedTypeKeyword Keyword,
                                          NestedNameSpecifierLoc QualifierLoc,
                                          QualType T) {
if (const TagType *TT = T->getAs<TagType>()) {
  TagDecl* TD = TT->getDecl();

  SourceLocation TagLocation = KeywordLoc;

  IdentifierInfo *Id = TD->getIdentifier();

  // TODO: should we even warn on struct/class mismatches for this?  Seems
  // like it's likely to produce a lot of spurious errors.
  if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {
    TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
    if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
                                              TagLocation, Id)) {
      SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
        << Id
        << FixItHint::CreateReplacement(SourceRange(TagLocation),
                                        TD->getKindName());
      SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
    }
  }
}

return inherited::RebuildElaboratedType(KeywordLoc, Keyword, QualifierLoc, T);
1665}

1667TemplateName TemplateInstantiator::TransformTemplateName(
  CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc,
  QualType ObjectType, NamedDecl *FirstQualifierInScope,
  bool AllowInjectedClassName) {
if (TemplateTemplateParmDecl *TTP
     = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
    // If the corresponding template argument is NULL or non-existent, it's
    // because we are performing instantiation from explicitly-specified
    // template arguments in a function template, but there were some
    // arguments left unspecified.
    if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
                                          TTP->getPosition()))
      return Name;

    TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());

    if (TemplateArgs.isRewrite()) {
      // We're rewriting the template parameter as a reference to another
      // template parameter.
      if (Arg.getKind() == TemplateArgument::Pack) {
        assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1689, __extension__
 __PRETTY_FUNCTION__))
               "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1689, __extension__
 __PRETTY_FUNCTION__));
        Arg = Arg.pack_begin()->getPackExpansionPattern();
      }
      assert(Arg.getKind() == TemplateArgument::Template &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Template && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1693, __extension__
 __PRETTY_FUNCTION__))
             "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Template && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1693, __extension__
 __PRETTY_FUNCTION__));
      return Arg.getAsTemplate();
    }

    auto [AssociatedDecl, Final] =
        TemplateArgs.getAssociatedDecl(TTP->getDepth());
    std::optional<unsigned> PackIndex;
    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1702, __extension__
 __PRETTY_FUNCTION__))
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1702, __extension__
 __PRETTY_FUNCTION__));

      if (getSema().ArgumentPackSubstitutionIndex == -1) {
        // We have the template argument pack to substitute, but we're not
        // actually expanding the enclosing pack expansion yet. So, just
        // keep the entire argument pack.
        return getSema().Context.getSubstTemplateTemplateParmPack(
            Arg, AssociatedDecl, TTP->getIndex(), Final);
      }

      PackIndex = getPackIndex(Arg);
      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && "Null template template argument")(static_cast <bool> (!Template.isNull() && "Null template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1717, __extension__
 __PRETTY_FUNCTION__));
    assert(!Template.getAsQualifiedTemplateName() &&(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
 (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1719, __extension__
 __PRETTY_FUNCTION__))
           "template decl to substitute is qualified?")(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
 (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1719, __extension__
 __PRETTY_FUNCTION__));

    if (Final)
      return Template;
    return getSema().Context.getSubstTemplateTemplateParm(
        Template, AssociatedDecl, TTP->getIndex(), PackIndex);
  }
}

if (SubstTemplateTemplateParmPackStorage *SubstPack
    = Name.getAsSubstTemplateTemplateParmPack()) {
  if (getSema().ArgumentPackSubstitutionIndex == -1)
    return Name;

  TemplateArgument Pack = SubstPack->getArgumentPack();
  TemplateName Template =
      getPackSubstitutedTemplateArgument(getSema(), Pack).getAsTemplate();
  if (SubstPack->getFinal())
    return Template;
  return getSema().Context.getSubstTemplateTemplateParm(
      Template.getNameToSubstitute(), SubstPack->getAssociatedDecl(),
      SubstPack->getIndex(), getPackIndex(Pack));
}

return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
                                        FirstQualifierInScope,
                                        AllowInjectedClassName);
1746}

1748ExprResult
1749TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
if (!E->isTypeDependent())
  return E;

return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentKind());
1754}

1756ExprResult
1757TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
                                             NonTypeTemplateParmDecl *NTTP) {
// If the corresponding template argument is NULL or non-existent, it's
// because we are performing instantiation from explicitly-specified
// template arguments in a function template, but there were some
// arguments left unspecified.
if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
                                      NTTP->getPosition()))
  return E;

TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());

if (TemplateArgs.isRewrite()) {
  // We're rewriting the template parameter as a reference to another
  // template parameter.
  if (Arg.getKind() == TemplateArgument::Pack) {
    assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1774, __extension__
 __PRETTY_FUNCTION__))
           "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1774, __extension__
 __PRETTY_FUNCTION__));
    Arg = Arg.pack_begin()->getPackExpansionPattern();
  }
  assert(Arg.getKind() == TemplateArgument::Expression &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1778, __extension__
 __PRETTY_FUNCTION__))
         "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1778, __extension__
 __PRETTY_FUNCTION__));
  // FIXME: This can lead to the same subexpression appearing multiple times
  // in a complete expression.
  return Arg.getAsExpr();
}

auto [AssociatedDecl, _] = TemplateArgs.getAssociatedDecl(NTTP->getDepth());
std::optional<unsigned> PackIndex;
if (NTTP->isParameterPack()) {
  assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1788, __extension__
 __PRETTY_FUNCTION__))
         "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1788, __extension__
 __PRETTY_FUNCTION__));

  if (getSema().ArgumentPackSubstitutionIndex == -1) {
    // We have an argument pack, but we can't select a particular argument
    // out of it yet. Therefore, we'll build an expression to hold on to that
    // argument pack.
    QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
                                            E->getLocation(),
                                            NTTP->getDeclName());
    if (TargetType.isNull())
      return ExprError();

    QualType ExprType = TargetType.getNonLValueExprType(SemaRef.Context);
    if (TargetType->isRecordType())
      ExprType.addConst();
    // FIXME: Pass in Final.
    return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
        ExprType, TargetType->isReferenceType() ? VK_LValue : VK_PRValue,
        E->getLocation(), Arg, AssociatedDecl, NTTP->getPosition());
  }
  PackIndex = getPackIndex(Arg);
  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
}
// FIXME: Don't put subst node on Final replacement.
return transformNonTypeTemplateParmRef(AssociatedDecl, NTTP, E->getLocation(),
                                       Arg, PackIndex);
1814}

1816const LoopHintAttr *
1817TemplateInstantiator::TransformLoopHintAttr(const LoopHintAttr *LH) {
Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();

if (TransformedExpr == LH->getValue())
  return LH;

// Generate error if there is a problem with the value.
if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
  return LH;

// Create new LoopHintValueAttr with integral expression in place of the
// non-type template parameter.
return LoopHintAttr::CreateImplicit(getSema().Context, LH->getOption(),
                                    LH->getState(), TransformedExpr, *LH);
1831}
1832const NoInlineAttr *TemplateInstantiator::TransformStmtNoInlineAttr(
  const Stmt *OrigS, const Stmt *InstS, const NoInlineAttr *A) {
if (!A || getSema().CheckNoInlineAttr(OrigS, InstS, *A))
  return nullptr;

return A;
1838}
1839const AlwaysInlineAttr *TemplateInstantiator::TransformStmtAlwaysInlineAttr(
  const Stmt *OrigS, const Stmt *InstS, const AlwaysInlineAttr *A) {
if (!A || getSema().CheckAlwaysInlineAttr(OrigS, InstS, *A))
  return nullptr;

return A;
1845}

1847ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
  Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm,
  SourceLocation loc, TemplateArgument arg,
  std::optional<unsigned> PackIndex) {
ExprResult result;

// Determine the substituted parameter type. We can usually infer this from
// the template argument, but not always.
auto SubstParamType = [&] {
  QualType T;
  if (parm->isExpandedParameterPack())
    T = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
  else
    T = parm->getType();
  if (parm->isParameterPack() && isa<PackExpansionType>(T))
    T = cast<PackExpansionType>(T)->getPattern();
  return SemaRef.SubstType(T, TemplateArgs, loc, parm->getDeclName());
};

bool refParam = false;

// The template argument itself might be an expression, in which case we just
// return that expression. This happens when substituting into an alias
// template.
if (arg.getKind() == TemplateArgument::Expression) {
  Expr *argExpr = arg.getAsExpr();
  result = argExpr;
  if (argExpr->isLValue()) {
    if (argExpr->getType()->isRecordType()) {
      // Check whether the parameter was actually a reference.
      QualType paramType = SubstParamType();
      if (paramType.isNull())
        return ExprError();
      refParam = paramType->isReferenceType();
    } else {
      refParam = true;
    }
  }
} else if (arg.getKind() == TemplateArgument::Declaration ||
           arg.getKind() == TemplateArgument::NullPtr) {
  ValueDecl *VD;
  if (arg.getKind() == TemplateArgument::Declaration) {
    VD = arg.getAsDecl();

    // Find the instantiation of the template argument.  This is
    // required for nested templates.
    VD = cast_or_null<ValueDecl>(
           getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
    if (!VD)
      return ExprError();
  } else {
    // Propagate NULL template argument.
    VD = nullptr;
  }

  QualType paramType = VD ? arg.getParamTypeForDecl() : arg.getNullPtrType();
  assert(!paramType.isNull() && "type substitution failed for param type")(static_cast <bool> (!paramType.isNull() && "type substitution failed for param type"
) ? void (0) : __assert_fail ("!paramType.isNull() && \"type substitution failed for param type\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1903, __extension__
 __PRETTY_FUNCTION__));
  assert(!paramType->isDependentType() && "param type still dependent")(static_cast <bool> (!paramType->isDependentType() &&
 "param type still dependent") ? void (0) : __assert_fail ("!paramType->isDependentType() && \"param type still dependent\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1904, __extension__
 __PRETTY_FUNCTION__));
  result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, paramType, loc);
  refParam = paramType->isReferenceType();
} else {
  result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
  assert(result.isInvalid() ||(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1911, __extension__
 __PRETTY_FUNCTION__))
         SemaRef.Context.hasSameType(result.get()->getType(),(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1911, __extension__
 __PRETTY_FUNCTION__))
                                     arg.getIntegralType()))(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 1911, __extension__
 __PRETTY_FUNCTION__));
}

if (result.isInvalid())
  return ExprError();

Expr *resultExpr = result.get();
// FIXME: Don't put subst node on final replacement.
return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
    resultExpr->getType(), resultExpr->getValueKind(), loc, resultExpr,
    AssociatedDecl, parm->getIndex(), PackIndex, refParam);
1922}

1924ExprResult
1925TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
                                        SubstNonTypeTemplateParmPackExpr *E) {
if (getSema().ArgumentPackSubstitutionIndex == -1) {
  // We aren't expanding the parameter pack, so just return ourselves.
  return E;
}

TemplateArgument Pack = E->getArgumentPack();
TemplateArgument Arg = getPackSubstitutedTemplateArgument(getSema(), Pack);
// FIXME: Don't put subst node on final replacement.
return transformNonTypeTemplateParmRef(
    E->getAssociatedDecl(), E->getParameterPack(),
    E->getParameterPackLocation(), Arg, getPackIndex(Pack));
1938}

1940ExprResult
1941TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
                                        SubstNonTypeTemplateParmExpr *E) {
ExprResult SubstReplacement = E->getReplacement();
if (!isa<ConstantExpr>(SubstReplacement.get()))
  SubstReplacement = TransformExpr(E->getReplacement());
if (SubstReplacement.isInvalid())
  return true;
QualType SubstType = TransformType(E->getParameterType(getSema().Context));
if (SubstType.isNull())
  return true;
// The type may have been previously dependent and not now, which means we
// might have to implicit cast the argument to the new type, for example:
// template<auto T, decltype(T) U>
// concept C = sizeof(U) == 4;
// void foo() requires C<2, 'a'> { }
// When normalizing foo(), we first form the normalized constraints of C:
// AtomicExpr(sizeof(U) == 4,
//            U=SubstNonTypeTemplateParmExpr(Param=U,
//                                           Expr=DeclRef(U),
//                                           Type=decltype(T)))
// Then we substitute T = 2, U = 'a' into the parameter mapping, and need to
// produce:
// AtomicExpr(sizeof(U) == 4,
//            U=SubstNonTypeTemplateParmExpr(Param=U,
//                                           Expr=ImpCast(
//                                               decltype(2),
//                                               SubstNTTPE(Param=U, Expr='a',
//                                                          Type=char)),
//                                           Type=decltype(2)))
// The call to CheckTemplateArgument here produces the ImpCast.
TemplateArgument SugaredConverted, CanonicalConverted;
if (SemaRef
        .CheckTemplateArgument(E->getParameter(), SubstType,
                               SubstReplacement.get(), SugaredConverted,
                               CanonicalConverted, Sema::CTAK_Specified)
        .isInvalid())
  return true;
return transformNonTypeTemplateParmRef(E->getAssociatedDecl(),
                                       E->getParameter(), E->getExprLoc(),
                                       SugaredConverted, E->getPackIndex());
1981}

1983ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(VarDecl *PD,
                                                     SourceLocation Loc) {
DeclarationNameInfo NameInfo(PD->getDeclName(), Loc);
return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD);
1987}

1989ExprResult
1990TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
if (getSema().ArgumentPackSubstitutionIndex != -1) {
  // We can expand this parameter pack now.
  VarDecl *D = E->getExpansion(getSema().ArgumentPackSubstitutionIndex);
  VarDecl *VD = cast_or_null<VarDecl>(TransformDecl(E->getExprLoc(), D));
  if (!VD)
    return ExprError();
  return RebuildVarDeclRefExpr(VD, E->getExprLoc());
}

QualType T = TransformType(E->getType());
if (T.isNull())
  return ExprError();

// Transform each of the parameter expansions into the corresponding
// parameters in the instantiation of the function decl.
SmallVector<VarDecl *, 8> Vars;
Vars.reserve(E->getNumExpansions());
for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
     I != End; ++I) {
  VarDecl *D = cast_or_null<VarDecl>(TransformDecl(E->getExprLoc(), *I));
  if (!D)
    return ExprError();
  Vars.push_back(D);
}

auto *PackExpr =
    FunctionParmPackExpr::Create(getSema().Context, T, E->getParameterPack(),
                                 E->getParameterPackLocation(), Vars);
getSema().MarkFunctionParmPackReferenced(PackExpr);
return PackExpr;
2021}

2023ExprResult
2024TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
                                                     VarDecl *PD) {
typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
  = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
assert(Found && "no instantiation for parameter pack")(static_cast <bool> (Found && "no instantiation for parameter pack"
) ? void (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2029, __extension__
 __PRETTY_FUNCTION__));

Decl *TransformedDecl;
if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
  // If this is a reference to a function parameter pack which we can
  // substitute but can't yet expand, build a FunctionParmPackExpr for it.
  if (getSema().ArgumentPackSubstitutionIndex == -1) {
    QualType T = TransformType(E->getType());
    if (T.isNull())
      return ExprError();
    auto *PackExpr = FunctionParmPackExpr::Create(getSema().Context, T, PD,
                                                  E->getExprLoc(), *Pack);
    getSema().MarkFunctionParmPackReferenced(PackExpr);
    return PackExpr;
  }

  TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
} else {
  TransformedDecl = Found->get<Decl*>();
}

// We have either an unexpanded pack or a specific expansion.
return RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl), E->getExprLoc());
2052}

2054ExprResult
2055TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
NamedDecl *D = E->getDecl();

// Handle references to non-type template parameters and non-type template
// parameter packs.
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
  if (NTTP->getDepth() < TemplateArgs.getNumLevels())
    return TransformTemplateParmRefExpr(E, NTTP);

  // We have a non-type template parameter that isn't fully substituted;
  // FindInstantiatedDecl will find it in the local instantiation scope.
}

// Handle references to function parameter packs.
if (VarDecl *PD = dyn_cast<VarDecl>(D))
  if (PD->isParameterPack())
    return TransformFunctionParmPackRefExpr(E, PD);

return inherited::TransformDeclRefExpr(E);
2074}

2076ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
  CXXDefaultArgExpr *E) {
assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2080, __extension__
 __PRETTY_FUNCTION__))
           getDescribedFunctionTemplate() &&(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2080, __extension__
 __PRETTY_FUNCTION__))
       "Default arg expressions are never formed in dependent cases.")(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2080, __extension__
 __PRETTY_FUNCTION__));
return SemaRef.BuildCXXDefaultArgExpr(
    E->getUsedLocation(), cast<FunctionDecl>(E->getParam()->getDeclContext()),
    E->getParam());
2084}

2086template<typename Fn>
2087QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
                               FunctionProtoTypeLoc TL,
                               CXXRecordDecl *ThisContext,
                               Qualifiers ThisTypeQuals,
                               Fn TransformExceptionSpec) {
// We need a local instantiation scope for this function prototype.
LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
return inherited::TransformFunctionProtoType(
    TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
2096}

2098ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
  ParmVarDecl *OldParm, int indexAdjustment,
  std::optional<unsigned> NumExpansions, bool ExpectParameterPack) {
auto NewParm = SemaRef.SubstParmVarDecl(
    OldParm, TemplateArgs, indexAdjustment, NumExpansions,
    ExpectParameterPack, EvaluateConstraints);
if (NewParm && SemaRef.getLangOpts().OpenCL)
  SemaRef.deduceOpenCLAddressSpace(NewParm);
return NewParm;
2107}

2109QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
  TypeLocBuilder &TLB, bool SuppressObjCLifetime, bool Final,
  Decl *AssociatedDecl, unsigned Index, std::optional<unsigned> PackIndex,
  TemplateArgument Arg, SourceLocation NameLoc) {
QualType Replacement = Arg.getAsType();

// If the template parameter had ObjC lifetime qualifiers,
// then any such qualifiers on the replacement type are ignored.
if (SuppressObjCLifetime) {
  Qualifiers RQs;
  RQs = Replacement.getQualifiers();
  RQs.removeObjCLifetime();
  Replacement =
      SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), RQs);
}

if (Final) {
  TLB.pushTrivial(SemaRef.Context, Replacement, NameLoc);
  return Replacement;
}
// TODO: only do this uniquing once, at the start of instantiation.
QualType Result = getSema().Context.getSubstTemplateTypeParmType(
    Replacement, AssociatedDecl, Index, PackIndex);
SubstTemplateTypeParmTypeLoc NewTL =
    TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(NameLoc);
return Result;
2136}

2138QualType
2139TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                                  TemplateTypeParmTypeLoc TL,
                                                  bool SuppressObjCLifetime) {
const TemplateTypeParmType *T = TL.getTypePtr();
if (T->getDepth() < TemplateArgs.getNumLevels()) {
  // Replace the template type parameter with its corresponding
  // template argument.

  // If the corresponding template argument is NULL or doesn't exist, it's
  // because we are performing instantiation from explicitly-specified
  // template arguments in a function template class, but there were some
  // arguments left unspecified.
  if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
    TemplateTypeParmTypeLoc NewTL
      = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
    NewTL.setNameLoc(TL.getNameLoc());
    return TL.getType();
  }

  TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());

  if (TemplateArgs.isRewrite()) {
    // We're rewriting the template parameter as a reference to another
    // template parameter.
    if (Arg.getKind() == TemplateArgument::Pack) {
      assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2165, __extension__
 __PRETTY_FUNCTION__))
             "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2165, __extension__
 __PRETTY_FUNCTION__));
      Arg = Arg.pack_begin()->getPackExpansionPattern();
    }
    assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2169, __extension__
 __PRETTY_FUNCTION__))
           "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2169, __extension__
 __PRETTY_FUNCTION__));
    QualType NewT = Arg.getAsType();
    assert(isa<TemplateTypeParmType>(NewT) &&(static_cast <bool> (isa<TemplateTypeParmType>(NewT
) && "type parm not rewritten to type parm") ? void (
0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2172, __extension__
 __PRETTY_FUNCTION__))
           "type parm not rewritten to type parm")(static_cast <bool> (isa<TemplateTypeParmType>(NewT
) && "type parm not rewritten to type parm") ? void (
0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2172, __extension__
 __PRETTY_FUNCTION__));
    auto NewTL = TLB.push<TemplateTypeParmTypeLoc>(NewT);
    NewTL.setNameLoc(TL.getNameLoc());
    return NewT;
  }

  auto [AssociatedDecl, Final] =
      TemplateArgs.getAssociatedDecl(T->getDepth());
  std::optional<unsigned> PackIndex;
  if (T->isParameterPack()) {
    assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2183, __extension__
 __PRETTY_FUNCTION__))
           "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2183, __extension__
 __PRETTY_FUNCTION__));

    if (getSema().ArgumentPackSubstitutionIndex == -1) {
      // We have the template argument pack, but we're not expanding the
      // enclosing pack expansion yet. Just save the template argument
      // pack for later substitution.
      QualType Result = getSema().Context.getSubstTemplateTypeParmPackType(
          AssociatedDecl, T->getIndex(), Final, Arg);
      SubstTemplateTypeParmPackTypeLoc NewTL
        = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
      NewTL.setNameLoc(TL.getNameLoc());
      return Result;
    }

    // PackIndex starts from last element.
    PackIndex = getPackIndex(Arg);
    Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
  }

  assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
 : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2203, __extension__
 __PRETTY_FUNCTION__))
         "Template argument kind mismatch")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
 : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2203, __extension__
 __PRETTY_FUNCTION__));

  return BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,
                                        AssociatedDecl, T->getIndex(),
                                        PackIndex, Arg, TL.getNameLoc());
}

// The template type parameter comes from an inner template (e.g.,
// the template parameter list of a member template inside the
// template we are instantiating). Create a new template type
// parameter with the template "level" reduced by one.
TemplateTypeParmDecl *NewTTPDecl = nullptr;
if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
  NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
      TransformDecl(TL.getNameLoc(), OldTTPDecl));
QualType Result = getSema().Context.getTemplateTypeParmType(
    T->getDepth() - TemplateArgs.getNumSubstitutedLevels(), T->getIndex(),
    T->isParameterPack(), NewTTPDecl);
TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
2224}

2226QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
  TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL,
  bool SuppressObjCLifetime) {
const SubstTemplateTypeParmPackType *T = TL.getTypePtr();

Decl *NewReplaced = TransformDecl(TL.getNameLoc(), T->getAssociatedDecl());

if (getSema().ArgumentPackSubstitutionIndex == -1) {
  // We aren't expanding the parameter pack, so just return ourselves.
  QualType Result = TL.getType();
  if (NewReplaced != T->getAssociatedDecl())
    Result = getSema().Context.getSubstTemplateTypeParmPackType(
        NewReplaced, T->getIndex(), T->getFinal(), T->getArgumentPack());
  SubstTemplateTypeParmPackTypeLoc NewTL =
      TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
  return Result;
}

TemplateArgument Pack = T->getArgumentPack();
TemplateArgument Arg = getPackSubstitutedTemplateArgument(getSema(), Pack);
return BuildSubstTemplateTypeParmType(
    TLB, SuppressObjCLifetime, T->getFinal(), NewReplaced, T->getIndex(),
    getPackIndex(Pack), Arg, TL.getNameLoc());
2250}

2252template<typename EntityPrinter>
2253static concepts::Requirement::SubstitutionDiagnostic *
2254createSubstDiag(Sema &S, TemplateDeductionInfo &Info, EntityPrinter Printer) {
SmallString<128> Message;
SourceLocation ErrorLoc;
if (Info.hasSFINAEDiagnostic()) {
  PartialDiagnosticAt PDA(SourceLocation(),
                          PartialDiagnostic::NullDiagnostic{});
  Info.takeSFINAEDiagnostic(PDA);
  PDA.second.EmitToString(S.getDiagnostics(), Message);
  ErrorLoc = PDA.first;
} else {
  ErrorLoc = Info.getLocation();
}
char *MessageBuf = new (S.Context) char[Message.size()];
std::copy(Message.begin(), Message.end(), MessageBuf);
SmallString<128> Entity;
llvm::raw_svector_ostream OS(Entity);
Printer(OS);
char *EntityBuf = new (S.Context) char[Entity.size()];
std::copy(Entity.begin(), Entity.end(), EntityBuf);
return new (S.Context) concepts::Requirement::SubstitutionDiagnostic{
    StringRef(EntityBuf, Entity.size()), ErrorLoc,
    StringRef(MessageBuf, Message.size())};
2276}

2278ExprResult TemplateInstantiator::TransformRequiresTypeParams(
  SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE,
  RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params,
  SmallVectorImpl<QualType> &PTypes,
  SmallVectorImpl<ParmVarDecl *> &TransParams,
  Sema::ExtParameterInfoBuilder &PInfos) {

TemplateDeductionInfo Info(KWLoc);
Sema::InstantiatingTemplate TypeInst(SemaRef, KWLoc,
                                     RE, Info,
                                     SourceRange{KWLoc, RBraceLoc});
Sema::SFINAETrap Trap(SemaRef);

unsigned ErrorIdx;
if (getDerived().TransformFunctionTypeParams(
        KWLoc, Params, /*ParamTypes=*/nullptr, /*ParamInfos=*/nullptr, PTypes,
        &TransParams, PInfos, &ErrorIdx) ||
    Trap.hasErrorOccurred()) {
  SmallVector<concepts::Requirement *, 4> TransReqs;
  ParmVarDecl *FailedDecl = Params[ErrorIdx];
  // Add a 'failed' Requirement to contain the error that caused the failure
  // here.
  TransReqs.push_back(RebuildTypeRequirement(createSubstDiag(
      SemaRef, Info, [&](llvm::raw_ostream &OS) { OS << *FailedDecl; })));
  return getDerived().RebuildRequiresExpr(KWLoc, Body, TransParams, TransReqs,
                                          RBraceLoc);
}

return ExprResult{};
2307}

2309concepts::TypeRequirement *
2310TemplateInstantiator::TransformTypeRequirement(concepts::TypeRequirement *Req) {
if (!Req->isDependent() && !AlwaysRebuild())
  return Req;
if (Req->isSubstitutionFailure()) {
  if (AlwaysRebuild())
    return RebuildTypeRequirement(
            Req->getSubstitutionDiagnostic());
  return Req;
}

Sema::SFINAETrap Trap(SemaRef);
TemplateDeductionInfo Info(Req->getType()->getTypeLoc().getBeginLoc());
Sema::InstantiatingTemplate TypeInst(SemaRef,
    Req->getType()->getTypeLoc().getBeginLoc(), Req, Info,
    Req->getType()->getTypeLoc().getSourceRange());
if (TypeInst.isInvalid())
  return nullptr;
TypeSourceInfo *TransType = TransformType(Req->getType());
if (!TransType || Trap.hasErrorOccurred())
  return RebuildTypeRequirement(createSubstDiag(SemaRef, Info,
      [&] (llvm::raw_ostream& OS) {
          Req->getType()->getType().print(OS, SemaRef.getPrintingPolicy());
      }));
return RebuildTypeRequirement(TransType);
2334}

2336concepts::ExprRequirement *
2337TemplateInstantiator::TransformExprRequirement(concepts::ExprRequirement *Req) {
if (!Req->isDependent() && !AlwaysRebuild())
  return Req;

Sema::SFINAETrap Trap(SemaRef);

llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
    TransExpr;
if (Req->isExprSubstitutionFailure())
  TransExpr = Req->getExprSubstitutionDiagnostic();
else {
  Expr *E = Req->getExpr();
  TemplateDeductionInfo Info(E->getBeginLoc());
  Sema::InstantiatingTemplate ExprInst(SemaRef, E->getBeginLoc(), Req, Info,
                                       E->getSourceRange());
  if (ExprInst.isInvalid())
    return nullptr;
  ExprResult TransExprRes = TransformExpr(E);
  if (!TransExprRes.isInvalid() && !Trap.hasErrorOccurred() &&
      TransExprRes.get()->hasPlaceholderType())
    TransExprRes = SemaRef.CheckPlaceholderExpr(TransExprRes.get());
  if (TransExprRes.isInvalid() || Trap.hasErrorOccurred())
    TransExpr = createSubstDiag(SemaRef, Info, [&](llvm::raw_ostream &OS) {
      E->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
    });
  else
    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();
  TemplateDeductionInfo Info(OrigTPL->getTemplateLoc());
  Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
                                      Req, Info, OrigTPL->getSourceRange());
  if (TPLInst.isInvalid())
    return nullptr;
  TemplateParameterList *TPL = TransformTemplateParameterList(OrigTPL);
  if (!TPL)
    TransRetReq.emplace(createSubstDiag(SemaRef, Info,
        [&] (llvm::raw_ostream& OS) {
            RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
                ->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
        }));
  else {
    TPLInst.Clear();
    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/SemaTemplateInstantiate.cpp", 2392, __extension__
 __PRETTY_FUNCTION__));
if (Expr *E = TransExpr.dyn_cast<Expr *>())
  return RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(),
                                std::move(*TransRetReq));
return RebuildExprRequirement(
    TransExpr.get<concepts::Requirement::SubstitutionDiagnostic *>(),
    Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
2399}

2401concepts::NestedRequirement *
2402TemplateInstantiator::TransformNestedRequirement(
  concepts::NestedRequirement *Req) {
if (!Req->isDependent() && !AlwaysRebuild())
  return Req;
if (Req->hasInvalidConstraint()) {
  if (AlwaysRebuild())
    return RebuildNestedRequirement(Req->getInvalidConstraintEntity(),
                                    Req->getConstraintSatisfaction());
  return Req;
}
Sema::InstantiatingTemplate ReqInst(SemaRef,
    Req->getConstraintExpr()->getBeginLoc(), Req,
    Sema::InstantiatingTemplate::ConstraintsCheck{},
    Req->getConstraintExpr()->getSourceRange());

ExprResult TransConstraint;
ConstraintSatisfaction Satisfaction;
TemplateDeductionInfo Info(Req->getConstraintExpr()->getBeginLoc());
{
  EnterExpressionEvaluationContext ContextRAII(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  Sema::SFINAETrap Trap(SemaRef);
  Sema::InstantiatingTemplate ConstrInst(SemaRef,
      Req->getConstraintExpr()->getBeginLoc(), Req, Info,
      Req->getConstraintExpr()->getSourceRange());
  if (ConstrInst.isInvalid())
    return nullptr;
  llvm::SmallVector<Expr *> Result;
  if (!SemaRef.CheckConstraintSatisfaction(
          nullptr, {Req->getConstraintExpr()}, Result, TemplateArgs,
          Req->getConstraintExpr()->getSourceRange(), Satisfaction) &&
      !Result.empty())
    TransConstraint = Result[0];
  assert(!Trap.hasErrorOccurred() && "Substitution failures must be handled "(static_cast <bool> (!Trap.hasErrorOccurred() &&
 "Substitution failures must be handled " "by CheckConstraintSatisfaction."
) ? void (0) : __assert_fail ("!Trap.hasErrorOccurred() && \"Substitution failures must be handled \" \"by CheckConstraintSatisfaction.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2436, __extension__
 __PRETTY_FUNCTION__))
                                     "by CheckConstraintSatisfaction.")(static_cast <bool> (!Trap.hasErrorOccurred() &&
 "Substitution failures must be handled " "by CheckConstraintSatisfaction."
) ? void (0) : __assert_fail ("!Trap.hasErrorOccurred() && \"Substitution failures must be handled \" \"by CheckConstraintSatisfaction.\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2436, __extension__
 __PRETTY_FUNCTION__));
}
if (TransConstraint.isUsable() &&
    TransConstraint.get()->isInstantiationDependent())
  return new (SemaRef.Context)
      concepts::NestedRequirement(TransConstraint.get());
if (TransConstraint.isInvalid() || !TransConstraint.get() ||
    Satisfaction.HasSubstitutionFailure()) {
  SmallString<128> Entity;
  llvm::raw_svector_ostream OS(Entity);
  Req->getConstraintExpr()->printPretty(OS, nullptr,
                                        SemaRef.getPrintingPolicy());
  char *EntityBuf = new (SemaRef.Context) char[Entity.size()];
  std::copy(Entity.begin(), Entity.end(), EntityBuf);
  return new (SemaRef.Context) concepts::NestedRequirement(
      SemaRef.Context, StringRef(EntityBuf, Entity.size()), Satisfaction);
}
return new (SemaRef.Context) concepts::NestedRequirement(
    SemaRef.Context, TransConstraint.get(), Satisfaction);
2455}


2458/// Perform substitution on the type T with a given set of template
2459/// arguments.
2460///
2461/// This routine substitutes the given template arguments into the
2462/// type T and produces the instantiated type.
2463///
2464/// \param T the type into which the template arguments will be
2465/// substituted. If this type is not dependent, it will be returned
2466/// immediately.
2467///
2468/// \param Args the template arguments that will be
2469/// substituted for the top-level template parameters within T.
2470///
2471/// \param Loc the location in the source code where this substitution
2472/// is being performed. It will typically be the location of the
2473/// declarator (if we're instantiating the type of some declaration)
2474/// or the location of the type in the source code (if, e.g., we're
2475/// instantiating the type of a cast expression).
2476///
2477/// \param Entity the name of the entity associated with a declaration
2478/// being instantiated (if any). May be empty to indicate that there
2479/// is no such entity (if, e.g., this is a type that occurs as part of
2480/// a cast expression) or that the entity has no name (e.g., an
2481/// unnamed function parameter).
2482///
2483/// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
2484/// acceptable as the top level type of the result.
2485///
2486/// \returns If the instantiation succeeds, the instantiated
2487/// type. Otherwise, produces diagnostics and returns a NULL type.
2488TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              bool AllowDeducedTST) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2495, __extension__
 __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2495, __extension__
 __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2495, __extension__
 __PRETTY_FUNCTION__));

if (!T->getType()->isInstantiationDependentType() &&
    !T->getType()->isVariablyModifiedType())
  return T;

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
                       : Instantiator.TransformType(T);
2504}

2506TypeSourceInfo *Sema::SubstType(TypeLoc TL,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2512, __extension__
 __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2512, __extension__
 __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2512, __extension__
 __PRETTY_FUNCTION__));

if (TL.getType().isNull())
  return nullptr;

if (!TL.getType()->isInstantiationDependentType() &&
    !TL.getType()->isVariablyModifiedType()) {
  // FIXME: Make a copy of the TypeLoc data here, so that we can
  // return a new TypeSourceInfo. Inefficient!
  TypeLocBuilder TLB;
  TLB.pushFullCopy(TL);
  return TLB.getTypeSourceInfo(Context, TL.getType());
}

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
TypeLocBuilder TLB;
TLB.reserve(TL.getFullDataSize());
QualType Result = Instantiator.TransformType(TLB, TL);
if (Result.isNull())
  return nullptr;

return TLB.getTypeSourceInfo(Context, Result);
2534}

2536/// Deprecated form of the above.
2537QualType Sema::SubstType(QualType T,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SourceLocation Loc, DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2542, __extension__
 __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2542, __extension__
 __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2542, __extension__
 __PRETTY_FUNCTION__));

// If T is not a dependent type or a variably-modified type, there
// is nothing to do.
if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
  return T;

TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
return Instantiator.TransformType(T);
2551}

2553static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
if (T->getType()->isInstantiationDependentType() ||
    T->getType()->isVariablyModifiedType())
  return true;

TypeLoc TL = T->getTypeLoc().IgnoreParens();
if (!TL.getAs<FunctionProtoTypeLoc>())
  return false;

FunctionProtoTypeLoc FP = TL.castAs<FunctionProtoTypeLoc>();
for (ParmVarDecl *P : FP.getParams()) {
  // This must be synthesized from a typedef.
  if (!P) continue;

  // If there are any parameters, a new TypeSourceInfo that refers to the
  // instantiated parameters must be built.
  return true;
}

return false;
2573}

2575/// A form of SubstType intended specifically for instantiating the
2576/// type of a FunctionDecl.  Its purpose is solely to force the
2577/// instantiation of default-argument expressions and to avoid
2578/// instantiating an exception-specification.
2579TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              CXXRecordDecl *ThisContext,
                              Qualifiers ThisTypeQuals,
                              bool EvaluateConstraints) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2588, __extension__
 __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2588, __extension__
 __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2588, __extension__
 __PRETTY_FUNCTION__));

if (!NeedsInstantiationAsFunctionType(T))
  return T;

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
Instantiator.setEvaluateConstraints(EvaluateConstraints);

TypeLocBuilder TLB;

TypeLoc TL = T->getTypeLoc();
TLB.reserve(TL.getFullDataSize());

QualType Result;

if (FunctionProtoTypeLoc Proto =
        TL.IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
  // Instantiate the type, other than its exception specification. The
  // exception specification is instantiated in InitFunctionInstantiation
  // once we've built the FunctionDecl.
  // FIXME: Set the exception specification to EST_Uninstantiated here,
  // instead of rebuilding the function type again later.
  Result = Instantiator.TransformFunctionProtoType(
      TLB, Proto, ThisContext, ThisTypeQuals,
      [](FunctionProtoType::ExceptionSpecInfo &ESI,
         bool &Changed) { return false; });
} else {
  Result = Instantiator.TransformType(TLB, TL);
}
if (Result.isNull())
  return nullptr;

return TLB.getTypeSourceInfo(Context, Result);
2621}

2623bool Sema::SubstExceptionSpec(SourceLocation Loc,
                            FunctionProtoType::ExceptionSpecInfo &ESI,
                            SmallVectorImpl<QualType> &ExceptionStorage,
                            const MultiLevelTemplateArgumentList &Args) {
assert(ESI.Type != EST_Uninstantiated)(static_cast <bool> (ESI.Type != EST_Uninstantiated) ? void
 (0) : __assert_fail ("ESI.Type != EST_Uninstantiated", "clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2627, __extension__ __PRETTY_FUNCTION__));

bool Changed = false;
TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName());
return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
                                           Changed);
2633}

2635void Sema::SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
                            const MultiLevelTemplateArgumentList &Args) {
FunctionProtoType::ExceptionSpecInfo ESI =
    Proto->getExtProtoInfo().ExceptionSpec;

SmallVector<QualType, 4> ExceptionStorage;
if (SubstExceptionSpec(New->getTypeSourceInfo()->getTypeLoc().getEndLoc(),
                       ESI, ExceptionStorage, Args))
  // On error, recover by dropping the exception specification.
  ESI.Type = EST_None;

UpdateExceptionSpec(New, ESI);
2647}

2649namespace {

struct GetContainedInventedTypeParmVisitor :
  public TypeVisitor<GetContainedInventedTypeParmVisitor,
                     TemplateTypeParmDecl *> {
  using TypeVisitor<GetContainedInventedTypeParmVisitor,
                    TemplateTypeParmDecl *>::Visit;

  TemplateTypeParmDecl *Visit(QualType T) {
    if (T.isNull())
      return nullptr;
    return Visit(T.getTypePtr());
  }
  // The deduced type itself.
  TemplateTypeParmDecl *VisitTemplateTypeParmType(
      const TemplateTypeParmType *T) {
    if (!T->getDecl() || !T->getDecl()->isImplicit())
      return nullptr;
    return T->getDecl();
  }

  // Only these types can contain 'auto' types, and subsequently be replaced
  // by references to invented parameters.

  TemplateTypeParmDecl *VisitElaboratedType(const ElaboratedType *T) {
    return Visit(T->getNamedType());
  }

  TemplateTypeParmDecl *VisitPointerType(const PointerType *T) {
    return Visit(T->getPointeeType());
  }

  TemplateTypeParmDecl *VisitBlockPointerType(const BlockPointerType *T) {
    return Visit(T->getPointeeType());
  }

  TemplateTypeParmDecl *VisitReferenceType(const ReferenceType *T) {
    return Visit(T->getPointeeTypeAsWritten());
  }

  TemplateTypeParmDecl *VisitMemberPointerType(const MemberPointerType *T) {
    return Visit(T->getPointeeType());
  }

  TemplateTypeParmDecl *VisitArrayType(const ArrayType *T) {
    return Visit(T->getElementType());
  }

  TemplateTypeParmDecl *VisitDependentSizedExtVectorType(
    const DependentSizedExtVectorType *T) {
    return Visit(T->getElementType());
  }

  TemplateTypeParmDecl *VisitVectorType(const VectorType *T) {
    return Visit(T->getElementType());
  }

  TemplateTypeParmDecl *VisitFunctionProtoType(const FunctionProtoType *T) {
    return VisitFunctionType(T);
  }

  TemplateTypeParmDecl *VisitFunctionType(const FunctionType *T) {
    return Visit(T->getReturnType());
  }

  TemplateTypeParmDecl *VisitParenType(const ParenType *T) {
    return Visit(T->getInnerType());
  }

  TemplateTypeParmDecl *VisitAttributedType(const AttributedType *T) {
    return Visit(T->getModifiedType());
  }

  TemplateTypeParmDecl *VisitMacroQualifiedType(const MacroQualifiedType *T) {
    return Visit(T->getUnderlyingType());
  }

  TemplateTypeParmDecl *VisitAdjustedType(const AdjustedType *T) {
    return Visit(T->getOriginalType());
  }

  TemplateTypeParmDecl *VisitPackExpansionType(const PackExpansionType *T) {
    return Visit(T->getPattern());
  }
};

2735} // namespace

2737bool Sema::SubstTypeConstraint(
  TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  bool EvaluateConstraints) {
const ASTTemplateArgumentListInfo *TemplArgInfo =
    TC->getTemplateArgsAsWritten();

if (!EvaluateConstraints) {
  Inst->setTypeConstraint(TC->getNestedNameSpecifierLoc(),
                          TC->getConceptNameInfo(), TC->getNamedConcept(),
                          TC->getNamedConcept(), TemplArgInfo,
                          TC->getImmediatelyDeclaredConstraint());
  return false;
}

TemplateArgumentListInfo InstArgs;

if (TemplArgInfo) {
  InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
  InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
  if (SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
                             InstArgs))
    return true;
}
return AttachTypeConstraint(
    TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
    TC->getNamedConcept(), &InstArgs, Inst,
    Inst->isParameterPack()
        ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
              ->getEllipsisLoc()
        : SourceLocation());
2768}

2770ParmVarDecl *Sema::SubstParmVarDecl(
  ParmVarDecl *OldParm, const MultiLevelTemplateArgumentList &TemplateArgs,
  int indexAdjustment, std::optional<unsigned> NumExpansions,
  bool ExpectParameterPack, bool EvaluateConstraint) {
TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
TypeSourceInfo *NewDI = nullptr;

TypeLoc OldTL = OldDI->getTypeLoc();
if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {

  // We have a function parameter pack. Substitute into the pattern of the
  // expansion.
  NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
                    OldParm->getLocation(), OldParm->getDeclName());
  if (!NewDI)
    return nullptr;

  if (NewDI->getType()->containsUnexpandedParameterPack()) {
    // We still have unexpanded parameter packs, which means that
    // our function parameter is still a function parameter pack.
    // Therefore, make its type a pack expansion type.
    NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
                               NumExpansions);
  } else if (ExpectParameterPack) {
    // We expected to get a parameter pack but didn't (because the type
    // itself is not a pack expansion type), so complain. This can occur when
    // the substitution goes through an alias template that "loses" the
    // pack expansion.
    Diag(OldParm->getLocation(),
         diag::err_function_parameter_pack_without_parameter_packs)
      << NewDI->getType();
    return nullptr;
  }
} else {
  NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
                    OldParm->getDeclName());
}

if (!NewDI)
  return nullptr;

if (NewDI->getType()->isVoidType()) {
  Diag(OldParm->getLocation(), diag::err_param_with_void_type);
  return nullptr;
}

// In abbreviated templates, TemplateTypeParmDecls with possible
// TypeConstraints are created when the parameter list is originally parsed.
// The TypeConstraints can therefore reference other functions parameters in
// the abbreviated function template, which is why we must instantiate them
// here, when the instantiated versions of those referenced parameters are in
// scope.
if (TemplateTypeParmDecl *TTP =
        GetContainedInventedTypeParmVisitor().Visit(OldDI->getType())) {
  if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
    auto *Inst = cast_or_null<TemplateTypeParmDecl>(
        FindInstantiatedDecl(TTP->getLocation(), TTP, TemplateArgs));
    // We will first get here when instantiating the abbreviated function
    // template's described function, but we might also get here later.
    // Make sure we do not instantiate the TypeConstraint more than once.
    if (Inst && !Inst->getTypeConstraint()) {
      if (SubstTypeConstraint(Inst, TC, TemplateArgs, EvaluateConstraint))
        return nullptr;
    }
  }
}

ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
                                      OldParm->getInnerLocStart(),
                                      OldParm->getLocation(),
                                      OldParm->getIdentifier(),
                                      NewDI->getType(), NewDI,
                                      OldParm->getStorageClass());
if (!NewParm)
  return nullptr;

// Mark the (new) default argument as uninstantiated (if any).
if (OldParm->hasUninstantiatedDefaultArg()) {
  Expr *Arg = OldParm->getUninstantiatedDefaultArg();
  NewParm->setUninstantiatedDefaultArg(Arg);
} else if (OldParm->hasUnparsedDefaultArg()) {
  NewParm->setUnparsedDefaultArg();
  UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
} else if (Expr *Arg = OldParm->getDefaultArg()) {
  // Default arguments cannot be substituted until the declaration context
  // for the associated function or lambda capture class is available.
  // This is necessary for cases like the following where construction of
  // the lambda capture class for the outer lambda is dependent on the
  // parameter types but where the default argument is dependent on the
  // outer lambda's declaration context.
  //   template <typename T>
  //   auto f() {
  //     return [](T = []{ return T{}; }()) { return 0; };
  //   }
  NewParm->setUninstantiatedDefaultArg(Arg);
}

NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg());

if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
  // Add the new parameter to the instantiated parameter pack.
  CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm);
} else {
  // Introduce an Old -> New mapping
  CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);
}

// FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
// can be anything, is this right ?
NewParm->setDeclContext(CurContext);

NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
                      OldParm->getFunctionScopeIndex() + indexAdjustment);

InstantiateAttrs(TemplateArgs, OldParm, NewParm);

return NewParm;
2887}

2889/// Substitute the given template arguments into the given set of
2890/// parameters, producing the set of parameter types that would be generated
2891/// from such a substitution.
2892bool Sema::SubstParmTypes(
  SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
  const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  SmallVectorImpl<QualType> &ParamTypes,
  SmallVectorImpl<ParmVarDecl *> *OutParams,
  ExtParameterInfoBuilder &ParamInfos) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2901, __extension__
 __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2901, __extension__
 __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 2901, __extension__
 __PRETTY_FUNCTION__));

TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
                                  DeclarationName());
return Instantiator.TransformFunctionTypeParams(
    Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
2907}

2909/// Substitute the given template arguments into the default argument.
2910bool Sema::SubstDefaultArgument(
  SourceLocation Loc,
  ParmVarDecl *Param,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  bool ForCallExpr) {
FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
Expr *PatternExpr = Param->getUninstantiatedDefaultArg();

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

InstantiatingTemplate Inst(*this, Loc, Param, TemplateArgs.getInnermost());
if (Inst.isInvalid())
  return true;
if (Inst.isAlreadyInstantiating()) {
  Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
  Param->setInvalidDecl();
  return true;
}

ExprResult Result;
{
  // C++ [dcl.fct.default]p5:
  //   The names in the [default argument] expression are bound, and
  //   the semantic constraints are checked, at the point where the
  //   default argument expression appears.
  ContextRAII SavedContext(*this, FD);
  std::unique_ptr<LocalInstantiationScope> LIS;

  if (ForCallExpr) {
    // When instantiating a default argument due to use in a call expression,
    // an instantiation scope that includes the parameters of the callee is
    // required to satisfy references from the default argument. For example:
    //   template<typename T> void f(T a, int = decltype(a)());
    //   void g() { f(0); }
    LIS = std::make_unique<LocalInstantiationScope>(*this);
    FunctionDecl *PatternFD = FD->getTemplateInstantiationPattern(
        /*ForDefinition*/ false);
    if (addInstantiatedParametersToScope(FD, PatternFD, *LIS, TemplateArgs))
      return true;
  }

  runWithSufficientStackSpace(Loc, [&] {
    Result = SubstInitializer(PatternExpr, TemplateArgs,
                              /*DirectInit*/false);
  });
}
if (Result.isInvalid())
  return true;

if (ForCallExpr) {
  // Check the expression as an initializer for the parameter.
  InitializedEntity Entity
    = InitializedEntity::InitializeParameter(Context, Param);
  InitializationKind Kind = InitializationKind::CreateCopy(
      Param->getLocation(),
      /*FIXME:EqualLoc*/ PatternExpr->getBeginLoc());
  Expr *ResultE = Result.getAs<Expr>();

  InitializationSequence InitSeq(*this, Entity, Kind, ResultE);
  Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
  if (Result.isInvalid())
    return true;

  Result =
      ActOnFinishFullExpr(Result.getAs<Expr>(), Param->getOuterLocStart(),
                          /*DiscardedValue*/ false);
} else {
  // FIXME: Obtain the source location for the '=' token.
  SourceLocation EqualLoc = PatternExpr->getBeginLoc();
  Result = ConvertParamDefaultArgument(Param, Result.getAs<Expr>(), EqualLoc);
}
if (Result.isInvalid())
    return true;

// Remember the instantiated default argument.
Param->setDefaultArg(Result.getAs<Expr>());

return false;
2989}

2991/// Perform substitution on the base class specifiers of the
2992/// given class template specialization.
2993///
2994/// Produces a diagnostic and returns true on error, returns false and
2995/// attaches the instantiated base classes to the class template
2996/// specialization if successful.
2997bool
2998Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
                        CXXRecordDecl *Pattern,
                        const MultiLevelTemplateArgumentList &TemplateArgs) {
bool Invalid = false;
SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
for (const auto &Base : Pattern->bases()) {
  if (!Base.getType()->isDependentType()) {
    if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) {
      if (RD->isInvalidDecl())
        Instantiation->setInvalidDecl();
    }
    InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(Base));
    continue;
  }

  SourceLocation EllipsisLoc;
  TypeSourceInfo *BaseTypeLoc;
  if (Base.isPackExpansion()) {
    // This is a pack expansion. See whether we should expand it now, or
    // wait until later.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    collectUnexpandedParameterPacks(Base.getTypeSourceInfo()->getTypeLoc(),
                                    Unexpanded);
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions;
    if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(),
                                        Base.getSourceRange(),
                                        Unexpanded,
                                        TemplateArgs, ShouldExpand,
                                        RetainExpansion,
                                        NumExpansions)) {
      Invalid = true;
      continue;
    }

    // If we should expand this pack expansion now, do so.
    if (ShouldExpand) {
      for (unsigned I = 0; I != *NumExpansions; ++I) {
          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);

        TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
                                                TemplateArgs,
                                            Base.getSourceRange().getBegin(),
                                                DeclarationName());
        if (!BaseTypeLoc) {
          Invalid = true;
          continue;
        }

        if (CXXBaseSpecifier *InstantiatedBase
              = CheckBaseSpecifier(Instantiation,
                                   Base.getSourceRange(),
                                   Base.isVirtual(),
                                   Base.getAccessSpecifierAsWritten(),
                                   BaseTypeLoc,
                                   SourceLocation()))
          InstantiatedBases.push_back(InstantiatedBase);
        else
          Invalid = true;
      }

      continue;
    }

    // The resulting base specifier will (still) be a pack expansion.
    EllipsisLoc = Base.getEllipsisLoc();
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
    BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
                            TemplateArgs,
                            Base.getSourceRange().getBegin(),
                            DeclarationName());
  } else {
    BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
                            TemplateArgs,
                            Base.getSourceRange().getBegin(),
                            DeclarationName());
  }

  if (!BaseTypeLoc) {
    Invalid = true;
    continue;
  }

  if (CXXBaseSpecifier *InstantiatedBase
        = CheckBaseSpecifier(Instantiation,
                             Base.getSourceRange(),
                             Base.isVirtual(),
                             Base.getAccessSpecifierAsWritten(),
                             BaseTypeLoc,
                             EllipsisLoc))
    InstantiatedBases.push_back(InstantiatedBase);
  else
    Invalid = true;
}

if (!Invalid && AttachBaseSpecifiers(Instantiation, InstantiatedBases))
  Invalid = true;

return Invalid;
3098}

3100// Defined via #include from SemaTemplateInstantiateDecl.cpp
3101namespace clang {
namespace sema {
  Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
                          const MultiLevelTemplateArgumentList &TemplateArgs);
  Attr *instantiateTemplateAttributeForDecl(
      const Attr *At, ASTContext &C, Sema &S,
      const MultiLevelTemplateArgumentList &TemplateArgs);
}
3109}

3111/// Instantiate the definition of a class from a given pattern.
3112///
3113/// \param PointOfInstantiation The point of instantiation within the
3114/// source code.
3115///
3116/// \param Instantiation is the declaration whose definition is being
3117/// instantiated. This will be either a class template specialization
3118/// or a member class of a class template specialization.
3119///
3120/// \param Pattern is the pattern from which the instantiation
3121/// occurs. This will be either the declaration of a class template or
3122/// the declaration of a member class of a class template.
3123///
3124/// \param TemplateArgs The template arguments to be substituted into
3125/// the pattern.
3126///
3127/// \param TSK the kind of implicit or explicit instantiation to perform.
3128///
3129/// \param Complain whether to complain if the class cannot be instantiated due
3130/// to the lack of a definition.
3131///
3132/// \returns true if an error occurred, false otherwise.
3133bool
3134Sema::InstantiateClass(SourceLocation PointOfInstantiation,
                     CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
                     const MultiLevelTemplateArgumentList &TemplateArgs,
                     TemplateSpecializationKind TSK,
                     bool Complain) {
CXXRecordDecl *PatternDef
  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                              Instantiation->getInstantiatedFromMemberClass(),
                                   Pattern, PatternDef, TSK, Complain))
  return true;

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

Pattern = PatternDef;

// Record the point of instantiation.
if (MemberSpecializationInfo *MSInfo
      = Instantiation->getMemberSpecializationInfo()) {
  MSInfo->setTemplateSpecializationKind(TSK);
  MSInfo->setPointOfInstantiation(PointOfInstantiation);
} else if (ClassTemplateSpecializationDecl *Spec
      = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
  Spec->setTemplateSpecializationKind(TSK);
  Spec->setPointOfInstantiation(PointOfInstantiation);
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
if (Inst.isInvalid())
  return true;
assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller")(static_cast <bool> (!Inst.isAlreadyInstantiating() &&
 "should have been caught by caller") ? void (0) : __assert_fail
 ("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3170, __extension__
 __PRETTY_FUNCTION__));
PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
                                    "instantiating class definition");

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
ContextRAII SavedContext(*this, Instantiation);
EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// If this is an instantiation of a local class, merge this local
// instantiation scope with the enclosing scope. Otherwise, every
// instantiation of a class has its own local instantiation scope.
bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
LocalInstantiationScope Scope(*this, MergeWithParentScope);

// Some class state isn't processed immediately but delayed till class
// instantiation completes. We may not be ready to handle any delayed state
// already on the stack as it might correspond to a different class, so save
// it now and put it back later.
SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);

// Pull attributes from the pattern onto the instantiation.
InstantiateAttrs(TemplateArgs, Pattern, Instantiation);

// Start the definition of this instantiation.
Instantiation->startDefinition();

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

// FIXME: This loses the as-written tag kind for an explicit instantiation.
Instantiation->setTagKind(Pattern->getTagKind());

// Do substitution on the base class specifiers.
if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
  Instantiation->setInvalidDecl();

TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
Instantiator.setEvaluateConstraints(false);
SmallVector<Decl*, 4> Fields;
// Delay instantiation of late parsed attributes.
LateInstantiatedAttrVec LateAttrs;
Instantiator.enableLateAttributeInstantiation(&LateAttrs);

bool MightHaveConstexprVirtualFunctions = false;
for (auto *Member : Pattern->decls()) {
  // Don't instantiate members not belonging in this semantic context.
  // e.g. for:
  // @code
  //    template <int i> class A {
  //      class B *g;
  //    };
  // @endcode
  // 'class B' has the template as lexical context but semantically it is
  // introduced in namespace scope.
  if (Member->getDeclContext() != Pattern)
    continue;

  // BlockDecls can appear in a default-member-initializer. They must be the
  // child of a BlockExpr, so we only know how to instantiate them from there.
  // Similarly, lambda closure types are recreated when instantiating the
  // corresponding LambdaExpr.
  if (isa<BlockDecl>(Member) ||
      (isa<CXXRecordDecl>(Member) && cast<CXXRecordDecl>(Member)->isLambda()))
    continue;

  if (Member->isInvalidDecl()) {
    Instantiation->setInvalidDecl();
    continue;
  }

  Decl *NewMember = Instantiator.Visit(Member);
  if (NewMember) {
    if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
      Fields.push_back(Field);
    } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
      // C++11 [temp.inst]p1: The implicit instantiation of a class template
      // specialization causes the implicit instantiation of the definitions
      // of unscoped member enumerations.
      // Record a point of instantiation for this implicit instantiation.
      if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
          Enum->isCompleteDefinition()) {
        MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
        assert(MSInfo && "no spec info for member enum specialization")(static_cast <bool> (MSInfo && "no spec info for member enum specialization"
) ? void (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3255, __extension__
 __PRETTY_FUNCTION__));
        MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
        MSInfo->setPointOfInstantiation(PointOfInstantiation);
      }
    } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) {
      if (SA->isFailed()) {
        // A static_assert failed. Bail out; instantiating this
        // class is probably not meaningful.
        Instantiation->setInvalidDecl();
        break;
      }
    } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
      if (MD->isConstexpr() && !MD->getFriendObjectKind() &&
          (MD->isVirtualAsWritten() || Instantiation->getNumBases()))
        MightHaveConstexprVirtualFunctions = true;
    }

    if (NewMember->isInvalidDecl())
      Instantiation->setInvalidDecl();
  } else {
    // FIXME: Eventually, a NULL return will mean that one of the
    // instantiations was a semantic disaster, and we'll want to mark the
    // declaration invalid.
    // For now, we expect to skip some members that we can't yet handle.
  }
}

// Finish checking fields.
ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
            SourceLocation(), SourceLocation(), ParsedAttributesView());
CheckCompletedCXXClass(nullptr, Instantiation);

// Default arguments are parsed, if not instantiated. We can go instantiate
// default arg exprs for default constructors if necessary now. Unless we're
// parsing a class, in which case wait until that's finished.
if (ParsingClassDepth == 0)
  ActOnFinishCXXNonNestedClass();

// Instantiate late parsed attributes, and attach them to their decls.
// See Sema::InstantiateAttrs
for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
     E = LateAttrs.end(); I != E; ++I) {
  assert(CurrentInstantiationScope == Instantiator.getStartingScope())(static_cast <bool> (CurrentInstantiationScope == Instantiator
.getStartingScope()) ? void (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3297, __extension__
 __PRETTY_FUNCTION__));
  CurrentInstantiationScope = I->Scope;

  // Allow 'this' within late-parsed attributes.
  auto *ND = cast<NamedDecl>(I->NewDecl);
  auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
  CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
                             ND->isCXXInstanceMember());

  Attr *NewAttr =
    instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
  if (NewAttr)
    I->NewDecl->addAttr(NewAttr);
  LocalInstantiationScope::deleteScopes(I->Scope,
                                        Instantiator.getStartingScope());
}
Instantiator.disableLateAttributeInstantiation();
LateAttrs.clear();

ActOnFinishDelayedMemberInitializers(Instantiation);

// FIXME: We should do something similar for explicit instantiations so they
// end up in the right module.
if (TSK == TSK_ImplicitInstantiation) {
  Instantiation->setLocation(Pattern->getLocation());
  Instantiation->setLocStart(Pattern->getInnerLocStart());
  Instantiation->setBraceRange(Pattern->getBraceRange());
}

if (!Instantiation->isInvalidDecl()) {
  // Perform any dependent diagnostics from the pattern.
  if (Pattern->isDependentContext())
    PerformDependentDiagnostics(Pattern, TemplateArgs);

  // Instantiate any out-of-line class template partial
  // specializations now.
  for (TemplateDeclInstantiator::delayed_partial_spec_iterator
            P = Instantiator.delayed_partial_spec_begin(),
         PEnd = Instantiator.delayed_partial_spec_end();
       P != PEnd; ++P) {
    if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
            P->first, P->second)) {
      Instantiation->setInvalidDecl();
      break;
    }
  }

  // Instantiate any out-of-line variable template partial
  // specializations now.
  for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator
            P = Instantiator.delayed_var_partial_spec_begin(),
         PEnd = Instantiator.delayed_var_partial_spec_end();
       P != PEnd; ++P) {
    if (!Instantiator.InstantiateVarTemplatePartialSpecialization(
            P->first, P->second)) {
      Instantiation->setInvalidDecl();
      break;
    }
  }
}

// Exit the scope of this instantiation.
SavedContext.pop();

if (!Instantiation->isInvalidDecl()) {
  // Always emit the vtable for an explicit instantiation definition
  // of a polymorphic class template specialization. Otherwise, eagerly
  // instantiate only constexpr virtual functions in preparation for their use
  // in constant evaluation.
  if (TSK == TSK_ExplicitInstantiationDefinition)
    MarkVTableUsed(PointOfInstantiation, Instantiation, true);
  else if (MightHaveConstexprVirtualFunctions)
    MarkVirtualMembersReferenced(PointOfInstantiation, Instantiation,
                                 /*ConstexprOnly*/ true);
}

Consumer.HandleTagDeclDefinition(Instantiation);

return Instantiation->isInvalidDecl();
3376}

3378/// Instantiate the definition of an enum from a given pattern.
3379///
3380/// \param PointOfInstantiation The point of instantiation within the
3381///        source code.
3382/// \param Instantiation is the declaration whose definition is being
3383///        instantiated. This will be a member enumeration of a class
3384///        temploid specialization, or a local enumeration within a
3385///        function temploid specialization.
3386/// \param Pattern The templated declaration from which the instantiation
3387///        occurs.
3388/// \param TemplateArgs The template arguments to be substituted into
3389///        the pattern.
3390/// \param TSK The kind of implicit or explicit instantiation to perform.
3391///
3392/// \return \c true if an error occurred, \c false otherwise.
3393bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
                         EnumDecl *Instantiation, EnumDecl *Pattern,
                         const MultiLevelTemplateArgumentList &TemplateArgs,
                         TemplateSpecializationKind TSK) {
EnumDecl *PatternDef = Pattern->getDefinition();
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                               Instantiation->getInstantiatedFromMemberEnum(),
                                   Pattern, PatternDef, TSK,/*Complain*/true))
  return true;
Pattern = PatternDef;

// Record the point of instantiation.
if (MemberSpecializationInfo *MSInfo
      = Instantiation->getMemberSpecializationInfo()) {
  MSInfo->setTemplateSpecializationKind(TSK);
  MSInfo->setPointOfInstantiation(PointOfInstantiation);
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
if (Inst.isInvalid())
  return true;
if (Inst.isAlreadyInstantiating())
  return false;
PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
                                    "instantiating enum definition");

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

// Enter the scope of this instantiation. We don't use
// PushDeclContext because we don't have a scope.
ContextRAII SavedContext(*this, Instantiation);
EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);

// Pull attributes from the pattern onto the instantiation.
InstantiateAttrs(TemplateArgs, Pattern, Instantiation);

TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);

// Exit the scope of this instantiation.
SavedContext.pop();

return Instantiation->isInvalidDecl();
3441}


3444/// Instantiate the definition of a field from the given pattern.
3445///
3446/// \param PointOfInstantiation The point of instantiation within the
3447///        source code.
3448/// \param Instantiation is the declaration whose definition is being
3449///        instantiated. This will be a class of a class temploid
3450///        specialization, or a local enumeration within a function temploid
3451///        specialization.
3452/// \param Pattern The templated declaration from which the instantiation
3453///        occurs.
3454/// \param TemplateArgs The template arguments to be substituted into
3455///        the pattern.
3456///
3457/// \return \c true if an error occurred, \c false otherwise.
3458bool Sema::InstantiateInClassInitializer(
  SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
  FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
// If there is no initializer, we don't need to do anything.
if (!Pattern->hasInClassInitializer())
  return false;

assert(Instantiation->getInClassInitStyle() ==(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3467, __extension__
 __PRETTY_FUNCTION__))
           Pattern->getInClassInitStyle() &&(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3467, __extension__
 __PRETTY_FUNCTION__))
       "pattern and instantiation disagree about init style")(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3467, __extension__
 __PRETTY_FUNCTION__));

// Error out if we haven't parsed the initializer of the pattern yet because
// we are waiting for the closing brace of the outer class.
Expr *OldInit = Pattern->getInClassInitializer();
if (!OldInit) {
  RecordDecl *PatternRD = Pattern->getParent();
  RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext();
  Diag(PointOfInstantiation,
       diag::err_default_member_initializer_not_yet_parsed)
      << OutermostClass << Pattern;
  Diag(Pattern->getEndLoc(),
       diag::note_default_member_initializer_not_yet_parsed);
  Instantiation->setInvalidDecl();
  return true;
}

InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
if (Inst.isInvalid())
  return true;
if (Inst.isAlreadyInstantiating()) {
  // Error out if we hit an instantiation cycle for this initializer.
  Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle)
    << Instantiation;
  return true;
}
PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
                                    "instantiating default member init");

// Enter the scope of this instantiation. We don't use PushDeclContext because
// we don't have a scope.
ContextRAII SavedContext(*this, Instantiation->getParent());
EnterExpressionEvaluationContext EvalContext(
    *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
ExprEvalContexts.back().DelayedDefaultInitializationContext = {
    PointOfInstantiation, Instantiation, CurContext};

LocalInstantiationScope Scope(*this, true);

// Instantiate the initializer.
ActOnStartCXXInClassMemberInitializer();
CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), Qualifiers());

ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
                                      /*CXXDirectInit=*/false);
Expr *Init = NewInit.get();
assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class")(static_cast <bool> ((!Init || !isa<ParenListExpr>
(Init)) && "call-style init in class") ? void (0) : __assert_fail
 ("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3513, __extension__
 __PRETTY_FUNCTION__));
ActOnFinishCXXInClassMemberInitializer(
    Instantiation, Init ? Init->getBeginLoc() : SourceLocation(), Init);

if (auto *L = getASTMutationListener())
  L->DefaultMemberInitializerInstantiated(Instantiation);

// Return true if the in-class initializer is still missing.
return !Instantiation->getInClassInitializer();
3522}

3524namespace {
/// A partial specialization whose template arguments have matched
/// a given template-id.
struct PartialSpecMatchResult {
  ClassTemplatePartialSpecializationDecl *Partial;
  TemplateArgumentList *Args;
};
3531}

3533bool Sema::usesPartialOrExplicitSpecialization(
  SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) {
if (ClassTemplateSpec->getTemplateSpecializationKind() ==
    TSK_ExplicitSpecialization)
  return true;

SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
ClassTemplateSpec->getSpecializedTemplate()
                 ->getPartialSpecializations(PartialSpecs);
for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
  TemplateDeductionInfo Info(Loc);
  if (!DeduceTemplateArguments(PartialSpecs[I],
                               ClassTemplateSpec->getTemplateArgs(), Info))
    return true;
}

return false;
3550}

3552/// Get the instantiation pattern to use to instantiate the definition of a
3553/// given ClassTemplateSpecializationDecl (either the pattern of the primary
3554/// template or of a partial specialization).
3555static ActionResult<CXXRecordDecl *>
3556getPatternForClassTemplateSpecialization(
  Sema &S, SourceLocation PointOfInstantiation,
  ClassTemplateSpecializationDecl *ClassTemplateSpec,
  TemplateSpecializationKind TSK) {
Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
if (Inst.isInvalid())
  return {/*Invalid=*/true};
if (Inst.isAlreadyInstantiating())
  return {/*Invalid=*/false};

llvm::PointerUnion<ClassTemplateDecl *,
                   ClassTemplatePartialSpecializationDecl *>
    Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial();
if (!Specialized.is<ClassTemplatePartialSpecializationDecl *>()) {
  // Find best matching specialization.
  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();

  // C++ [temp.class.spec.match]p1:
  //   When a class template is used in a context that requires an
  //   instantiation of the class, it is necessary to determine
  //   whether the instantiation is to be generated using the primary
  //   template or one of the partial specializations. This is done by
  //   matching the template arguments of the class template
  //   specialization with the template argument lists of the partial
  //   specializations.
  typedef PartialSpecMatchResult MatchResult;
  SmallVector<MatchResult, 4> Matched;
  SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  Template->getPartialSpecializations(PartialSpecs);
  TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
    ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
    TemplateDeductionInfo Info(FailedCandidates.getLocation());
    if (Sema::TemplateDeductionResult Result = S.DeduceTemplateArguments(
            Partial, ClassTemplateSpec->getTemplateArgs(), Info)) {
      // Store the failed-deduction information for use in diagnostics, later.
      // TODO: Actually use the failed-deduction info?
      FailedCandidates.addCandidate().set(
          DeclAccessPair::make(Template, AS_public), Partial,
          MakeDeductionFailureInfo(S.Context, Result, Info));
      (void)Result;
    } else {
      Matched.push_back(PartialSpecMatchResult());
      Matched.back().Partial = Partial;
      Matched.back().Args = Info.takeCanonical();
    }
  }

  // If we're dealing with a member template where the template parameters
  // have been instantiated, this provides the original template parameters
  // from which the member template's parameters were instantiated.

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

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

      if (Ambiguous) {
        // Partial ordering did not produce a clear winner. Complain.
        Inst.Clear();
        ClassTemplateSpec->setInvalidDecl();
        S.Diag(PointOfInstantiation,
               diag::err_partial_spec_ordering_ambiguous)
            << ClassTemplateSpec;

        // Print the matching partial specializations.
        for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
                                                 PEnd = Matched.end();
             P != PEnd; ++P)
          S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
              << S.getTemplateArgumentBindingsText(
                     P->Partial->getTemplateParameters(), *P->Args);

        return {/*Invalid=*/true};
      }
    }

    ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
  } else {
    //   -- If no matches are found, the instantiation is generated
    //      from the primary template.
  }
}

CXXRecordDecl *Pattern = nullptr;
Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial();
if (auto *PartialSpec =
        Specialized.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
  // Instantiate using the best class template partial specialization.
  while (PartialSpec->getInstantiatedFromMember()) {
    // If we've found an explicit specialization of this class template,
    // stop here and use that as the pattern.
    if (PartialSpec->isMemberSpecialization())
      break;

    PartialSpec = PartialSpec->getInstantiatedFromMember();
  }
  Pattern = PartialSpec;
} else {
  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
  while (Template->getInstantiatedFromMemberTemplate()) {
    // If we've found an explicit specialization of this class template,
    // stop here and use that as the pattern.
    if (Template->isMemberSpecialization())
      break;

    Template = Template->getInstantiatedFromMemberTemplate();
  }
  Pattern = Template->getTemplatedDecl();
}

return Pattern;
3700}

3702bool Sema::InstantiateClassTemplateSpecialization(
  SourceLocation PointOfInstantiation,
  ClassTemplateSpecializationDecl *ClassTemplateSpec,
  TemplateSpecializationKind TSK, bool Complain) {
// Perform the actual instantiation on the canonical declaration.
ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
    ClassTemplateSpec->getCanonicalDecl());
if (ClassTemplateSpec->isInvalidDecl())
  return true;

ActionResult<CXXRecordDecl *> Pattern =
    getPatternForClassTemplateSpecialization(*this, PointOfInstantiation,
                                             ClassTemplateSpec, TSK);
if (!Pattern.isUsable())
  return Pattern.isInvalid();

return InstantiateClass(
    PointOfInstantiation, ClassTemplateSpec, Pattern.get(),
    getTemplateInstantiationArgs(ClassTemplateSpec), TSK, Complain);
3721}

3723/// Instantiates the definitions of all of the member
3724/// of the given class, which is an instantiation of a class template
3725/// or a member class of a template.
3726void
3727Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
                            CXXRecordDecl *Instantiation,
                      const MultiLevelTemplateArgumentList &TemplateArgs,
                            TemplateSpecializationKind TSK) {
// FIXME: We need to notify the ASTMutationListener that we did all of these
// things, in case we have an explicit instantiation definition in a PCM, a
// module, or preamble, and the declaration is in an imported AST.
assert((static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3738, __extension__
 __PRETTY_FUNCTION__))
    (TSK == TSK_ExplicitInstantiationDefinition ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3738, __extension__
 __PRETTY_FUNCTION__))
     TSK == TSK_ExplicitInstantiationDeclaration ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3738, __extension__
 __PRETTY_FUNCTION__))
     (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3738, __extension__
 __PRETTY_FUNCTION__))
    "Unexpected template specialization kind!")(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
 || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
 && Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3738, __extension__
 __PRETTY_FUNCTION__));
for (auto *D : Instantiation->decls()) {
  bool SuppressNew = false;
  if (auto *Function = dyn_cast<FunctionDecl>(D)) {
    if (FunctionDecl *Pattern =
            Function->getInstantiatedFromMemberFunction()) {

      if (Function->isIneligibleOrNotSelected())
        continue;

      if (Function->getTrailingRequiresClause()) {
        ConstraintSatisfaction Satisfaction;
        if (CheckFunctionConstraints(Function, Satisfaction) ||
            !Satisfaction.IsSatisfied) {
          continue;
        }
      }

      if (Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
        continue;

      MemberSpecializationInfo *MSInfo =
          Function->getMemberSpecializationInfo();
      assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3761, __extension__
 __PRETTY_FUNCTION__));
      if (MSInfo->getTemplateSpecializationKind()
                                               == TSK_ExplicitSpecialization)
        continue;

      if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
                                                 Function,
                                      MSInfo->getTemplateSpecializationKind(),
                                            MSInfo->getPointOfInstantiation(),
                                                 SuppressNew) ||
          SuppressNew)
        continue;

      // C++11 [temp.explicit]p8:
      //   An explicit instantiation definition that names a class template
      //   specialization explicitly instantiates the class template
      //   specialization and is only an explicit instantiation definition
      //   of members whose definition is visible at the point of
      //   instantiation.
      if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
        continue;

      Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);

      if (Function->isDefined()) {
        // Let the ASTConsumer know that this function has been explicitly
        // instantiated now, and its linkage might have changed.
        Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
      } else if (TSK == TSK_ExplicitInstantiationDefinition) {
        InstantiateFunctionDefinition(PointOfInstantiation, Function);
      } else if (TSK == TSK_ImplicitInstantiation) {
        PendingLocalImplicitInstantiations.push_back(
            std::make_pair(Function, PointOfInstantiation));
      }
    }
  } else if (auto *Var = dyn_cast<VarDecl>(D)) {
    if (isa<VarTemplateSpecializationDecl>(Var))
      continue;

    if (Var->isStaticDataMember()) {
      if (Var->hasAttr<ExcludeFromExplicitInstantiationAttr>())
        continue;

      MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
      assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3805, __extension__
 __PRETTY_FUNCTION__));
      if (MSInfo->getTemplateSpecializationKind()
                                               == TSK_ExplicitSpecialization)
        continue;

      if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
                                                 Var,
                                      MSInfo->getTemplateSpecializationKind(),
                                            MSInfo->getPointOfInstantiation(),
                                                 SuppressNew) ||
          SuppressNew)
        continue;

      if (TSK == TSK_ExplicitInstantiationDefinition) {
        // C++0x [temp.explicit]p8:
        //   An explicit instantiation definition that names a class template
        //   specialization explicitly instantiates the class template
        //   specialization and is only an explicit instantiation definition
        //   of members whose definition is visible at the point of
        //   instantiation.
        if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
          continue;

        Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
        InstantiateVariableDefinition(PointOfInstantiation, Var);
      } else {
        Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
      }
    }
  } else if (auto *Record = dyn_cast<CXXRecordDecl>(D)) {
    if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
      continue;

    // Always skip the injected-class-name, along with any
    // redeclarations of nested classes, since both would cause us
    // to try to instantiate the members of a class twice.
    // Skip closure types; they'll get instantiated when we instantiate
    // the corresponding lambda-expression.
    if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
        Record->isLambda())
      continue;

    MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
    assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3848, __extension__
 __PRETTY_FUNCTION__));

    if (MSInfo->getTemplateSpecializationKind()
                                              == TSK_ExplicitSpecialization)
      continue;

    if (Context.getTargetInfo().getTriple().isOSWindows() &&
        TSK == TSK_ExplicitInstantiationDeclaration) {
      // On Windows, explicit instantiation decl of the outer class doesn't
      // affect the inner class. Typically extern template declarations are
      // used in combination with dll import/export annotations, but those
      // are not propagated from the outer class templates to inner classes.
      // Therefore, do not instantiate inner classes on this platform, so
      // that users don't end up with undefined symbols during linking.
      continue;
    }

    if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
                                               Record,
                                      MSInfo->getTemplateSpecializationKind(),
                                            MSInfo->getPointOfInstantiation(),
                                               SuppressNew) ||
        SuppressNew)
      continue;

    CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
    assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3874, __extension__
 __PRETTY_FUNCTION__));

    if (!Record->getDefinition()) {
      if (!Pattern->getDefinition()) {
        // C++0x [temp.explicit]p8:
        //   An explicit instantiation definition that names a class template
        //   specialization explicitly instantiates the class template
        //   specialization and is only an explicit instantiation definition
        //   of members whose definition is visible at the point of
        //   instantiation.
        if (TSK == TSK_ExplicitInstantiationDeclaration) {
          MSInfo->setTemplateSpecializationKind(TSK);
          MSInfo->setPointOfInstantiation(PointOfInstantiation);
        }

        continue;
      }

      InstantiateClass(PointOfInstantiation, Record, Pattern,
                       TemplateArgs,
                       TSK);
    } else {
      if (TSK == TSK_ExplicitInstantiationDefinition &&
          Record->getTemplateSpecializationKind() ==
              TSK_ExplicitInstantiationDeclaration) {
        Record->setTemplateSpecializationKind(TSK);
        MarkVTableUsed(PointOfInstantiation, Record, true);
      }
    }

    Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
    if (Pattern)
      InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
                              TSK);
  } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
    MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
    assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3910, __extension__
 __PRETTY_FUNCTION__));

    if (MSInfo->getTemplateSpecializationKind()
          == TSK_ExplicitSpecialization)
      continue;

    if (CheckSpecializationInstantiationRedecl(
          PointOfInstantiation, TSK, Enum,
          MSInfo->getTemplateSpecializationKind(),
          MSInfo->getPointOfInstantiation(), SuppressNew) ||
        SuppressNew)
      continue;

    if (Enum->getDefinition())
      continue;

    EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
    assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3927, __extension__
 __PRETTY_FUNCTION__));

    if (TSK == TSK_ExplicitInstantiationDefinition) {
      if (!Pattern->getDefinition())
        continue;

      InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
    } else {
      MSInfo->setTemplateSpecializationKind(TSK);
      MSInfo->setPointOfInstantiation(PointOfInstantiation);
    }
  } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
    // No need to instantiate in-class initializers during explicit
    // instantiation.
    if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
      CXXRecordDecl *ClassPattern =
          Instantiation->getTemplateInstantiationPattern();
      DeclContext::lookup_result Lookup =
          ClassPattern->lookup(Field->getDeclName());
      FieldDecl *Pattern = Lookup.find_first<FieldDecl>();
      assert(Pattern)(static_cast <bool> (Pattern) ? void (0) : __assert_fail
 ("Pattern", "clang/lib/Sema/SemaTemplateInstantiate.cpp", 3947
, __extension__ __PRETTY_FUNCTION__));
      InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
                                    TemplateArgs);
    }
  }
}
3953}

3955/// Instantiate the definitions of all of the members of the
3956/// given class template specialization, which was named as part of an
3957/// explicit instantiation.
3958void
3959Sema::InstantiateClassTemplateSpecializationMembers(
                                         SourceLocation PointOfInstantiation,
                          ClassTemplateSpecializationDecl *ClassTemplateSpec,
                                             TemplateSpecializationKind TSK) {
// C++0x [temp.explicit]p7:
//   An explicit instantiation that names a class template
//   specialization is an explicit instantion of the same kind
//   (declaration or definition) of each of its members (not
//   including members inherited from base classes) that has not
//   been previously explicitly specialized in the translation unit
//   containing the explicit instantiation, except as described
//   below.
InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
                        getTemplateInstantiationArgs(ClassTemplateSpec),
                        TSK);
3974}

3976StmtResult
3977Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!S)
  return S;

TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformStmt(S);
3985}

3987bool Sema::SubstTemplateArguments(
  ArrayRef<TemplateArgumentLoc> Args,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  TemplateArgumentListInfo &Out) {
TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
3994}

3996ExprResult
3997Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!E)
  return E;

TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformExpr(E);
4005}

4007ExprResult
4008Sema::SubstConstraintExpr(Expr *E,
                        const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!E)
  return E;

// This is where we need to make sure we 'know' constraint checking needs to
// happen.
TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformExpr(E);
4018}

4020ExprResult Sema::SubstInitializer(Expr *Init,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        bool CXXDirectInit) {
TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformInitializer(Init, CXXDirectInit);
4026}

4028bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
                    const MultiLevelTemplateArgumentList &TemplateArgs,
                    SmallVectorImpl<Expr *> &Outputs) {
if (Exprs.empty())
  return false;

TemplateInstantiator Instantiator(*this, TemplateArgs,
                                  SourceLocation(),
                                  DeclarationName());
return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
                                   IsCall, Outputs);
4039}

4041NestedNameSpecifierLoc
4042Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
                      const MultiLevelTemplateArgumentList &TemplateArgs) {
if (!NNS)
  return NestedNameSpecifierLoc();

TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
                                  DeclarationName());
return Instantiator.TransformNestedNameSpecifierLoc(NNS);
4050}

4052/// Do template substitution on declaration name info.
4053DeclarationNameInfo
4054Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
                       const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
                                  NameInfo.getName());
return Instantiator.TransformDeclarationNameInfo(NameInfo);
4059}

4061TemplateName
4062Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
                      TemplateName Name, SourceLocation Loc,
                      const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
                                  DeclarationName());
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
return Instantiator.TransformTemplateName(SS, Name, Loc);
4070}

4072static const Decl *getCanonicalParmVarDecl(const Decl *D) {
// When storing ParmVarDecls in the local instantiation scope, we always
// want to use the ParmVarDecl from the canonical function declaration,
// since the map is then valid for any redeclaration or definition of that
// function.
if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
    unsigned i = PV->getFunctionScopeIndex();
    // This parameter might be from a freestanding function type within the
    // function and isn't necessarily referring to one of FD's parameters.
    if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
      return FD->getCanonicalDecl()->getParamDecl(i);
  }
}
return D;
4087}


4090llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
4091LocalInstantiationScope::findInstantiationOf(const Decl *D) {
D = getCanonicalParmVarDecl(D);
for (LocalInstantiationScope *Current = this; Current;
     Current = Current->Outer) {

  // Check if we found something within this scope.
  const Decl *CheckD = D;
  do {
    LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
    if (Found != Current->LocalDecls.end())
      return &Found->second;

    // If this is a tag declaration, it's possible that we need to look for
    // a previous declaration.
    if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
      CheckD = Tag->getPreviousDecl();
    else
      CheckD = nullptr;
  } while (CheckD);

  // If we aren't combined with our outer scope, we're done.
  if (!Current->CombineWithOuterScope)
    break;
}

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

// Local types referenced prior to definition may require instantiation.
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
  if (RD->isLocalClass())
    return nullptr;

// Enumeration types referenced prior to definition may appear as a result of
// error recovery.
if (isa<EnumDecl>(D))
  return nullptr;

// Materialized typedefs/type alias for implicit deduction guides may require
// instantiation.
if (isa<TypedefNameDecl>(D) &&
    isa<CXXDeductionGuideDecl>(D->getDeclContext()))
  return nullptr;

// If we didn't find the decl, then we either have a sema bug, or we have a
// forward reference to a label declaration.  Return null to indicate that
// we have an uninstantiated label.
assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope")(static_cast <bool> (isa<LabelDecl>(D) &&
 "declaration not instantiated in this scope") ? void (0) : __assert_fail
 ("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4141, __extension__
 __PRETTY_FUNCTION__));
return nullptr;
4143}

4145void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
D = getCanonicalParmVarDecl(D);
llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
if (Stored.isNull()) {
4149#ifndef NDEBUG
  // It should not be present in any surrounding scope either.
  LocalInstantiationScope *Current = this;
  while (Current->CombineWithOuterScope && Current->Outer) {
    Current = Current->Outer;
    assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4155, __extension__
 __PRETTY_FUNCTION__))
           "Instantiated local in inner and outer scopes")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4155, __extension__
 __PRETTY_FUNCTION__));
  }
4157#endif
  Stored = Inst;
} else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
  Pack->push_back(cast<VarDecl>(Inst));
} else {
  assert(Stored.get<Decl *>() == Inst && "Already instantiated this local")(static_cast <bool> (Stored.get<Decl *>() == Inst
 && "Already instantiated this local") ? void (0) : __assert_fail
 ("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4162, __extension__
 __PRETTY_FUNCTION__));
}
4164}

4166void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
                                                     VarDecl *Inst) {
D = getCanonicalParmVarDecl(D);
DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
Pack->push_back(Inst);
4171}

4173void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
4174#ifndef NDEBUG
// This should be the first time we've been told about this decl.
for (LocalInstantiationScope *Current = this;
     Current && Current->CombineWithOuterScope; Current = Current->Outer)
  assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4179, __extension__
 __PRETTY_FUNCTION__))
         "Creating local pack after instantiation of local")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4179, __extension__
 __PRETTY_FUNCTION__));
4180#endif

D = getCanonicalParmVarDecl(D);
llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
DeclArgumentPack *Pack = new DeclArgumentPack;
Stored = Pack;
ArgumentPacks.push_back(Pack);
4187}

4189bool LocalInstantiationScope::isLocalPackExpansion(const Decl *D) {
for (DeclArgumentPack *Pack : ArgumentPacks)
  if (llvm::is_contained(*Pack, D))
    return true;
return false;
4194}

4196void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
                                        const TemplateArgument *ExplicitArgs,
                                                  unsigned NumExplicitArgs) {
assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
 == Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4200, __extension__
 __PRETTY_FUNCTION__))
       "Already have a partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
 == Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4200, __extension__
 __PRETTY_FUNCTION__));
assert((!PartiallySubstitutedPack(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4203, __extension__
 __PRETTY_FUNCTION__))
        || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4203, __extension__
 __PRETTY_FUNCTION__))
       "Wrong number of arguments in partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "clang/lib/Sema/SemaTemplateInstantiate.cpp", 4203, __extension__
 __PRETTY_FUNCTION__));
PartiallySubstitutedPack = Pack;
ArgsInPartiallySubstitutedPack = ExplicitArgs;
NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
4207}

4209NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
                                       const TemplateArgument **ExplicitArgs,
                                            unsigned *NumExplicitArgs) const {
if (ExplicitArgs)
  *ExplicitArgs = nullptr;
if (NumExplicitArgs)
  *NumExplicitArgs = 0;

for (const LocalInstantiationScope *Current = this; Current;
     Current = Current->Outer) {
  if (Current->PartiallySubstitutedPack) {
    if (ExplicitArgs)
      *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
    if (NumExplicitArgs)
      *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;

    return Current->PartiallySubstitutedPack;
  }

  if (!Current->CombineWithOuterScope)
    break;
}

return nullptr;
4233}

←

/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()))
  return DI;

TypeLocBuilder TLB;

TypeLoc TL = DI->getTypeLoc();
TLB.reserve(TL.getFullDataSize());

QualType Result = getDerived().TransformType(TLB, TL);
if (Result.isNull())
  return nullptr;

return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4845}

4847template<typename Derived>
4848QualType
4849TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
switch (T.getTypeLocClass()) {
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);
if (!New_Under_TI)
  return QualType();

QualType Result = TL.getType();
TypeOfKind Kind = Result->getAs<TypeOfType>()->getKind();
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(),
3
←
Loop condition is false. Execution continues on line 13290→
                                  CEnd = E->capture_end();
     C != CEnd; ++C) {
2
←
Assuming 'C' is equal to 'CEnd'→
  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(),
5
←
Loop condition is true.  Entering loop body→
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
4
←
Assuming 'C' is not equal to 'CEnd'→
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (C->isImplicit())
6
←
Assuming the condition is false→
7
←
Taking false branch→
    break;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
8
←
Taking false branch→
    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())
9
←
Taking false branch→
    continue;

  // Rebuild init-captures, including the implied field declaration.
  if (E->isInitCapture(C)) {
10
←
Assuming the condition is true→
11
←
Taking true branch→
    TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];

    auto *OldVD = cast<VarDecl>(C->getCapturedVar());
12
←
The object is a 'CastReturnType'→
    llvm::SmallVector<Decl*, 4> NewVDs;

    for (InitCaptureInfoTy &Info : NewC.Expansions) {
13
←
Assuming '__begin0' is equal to '__end0'→
      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 (Invalid13.1
'Invalid' is false
1
'Invalid' is false
)
14
←
Taking false branch→
      break;

    getDerived().transformedLocalDecl(OldVD, NewVDs);
15
←
Calling 'TemplateInstantiator::transformedLocalDecl'→
    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