/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/TreeTransform.h

Bug Summary

File:	clang/lib/Sema/TreeTransform.h
Warning:	line 5617, column 24 Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateInstantiate.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-12/lib/clang/12.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema -I /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/include -I /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/build-llvm/include -I /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-12/lib/clang/12.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2021-01-16-002530-32805-1 -x c++ /build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp

/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/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/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTLambda.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/DeclTemplate.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/PrettyDeclStackTrace.h"
20#include "clang/AST/TypeVisitor.h"
21#include "clang/Basic/LangOptions.h"
22#include "clang/Basic/Stack.h"
23#include "clang/Basic/TargetInfo.h"
24#include "clang/Sema/DeclSpec.h"
25#include "clang/Sema/Initialization.h"
26#include "clang/Sema/Lookup.h"
27#include "clang/Sema/SemaConcept.h"
28#include "clang/Sema/SemaInternal.h"
29#include "clang/Sema/Template.h"
30#include "clang/Sema/TemplateDeduction.h"
31#include "clang/Sema/TemplateInstCallback.h"
32#include "llvm/Support/TimeProfiler.h"

34using namespace clang;
35using namespace sema;

37//===----------------------------------------------------------------------===/
38// Template Instantiation Support
39//===----------------------------------------------------------------------===/

41/// Retrieve the template argument list(s) that should be used to
42/// instantiate the definition of the given declaration.
43///
44/// \param D the declaration for which we are computing template instantiation
45/// arguments.
46///
47/// \param Innermost if non-NULL, the innermost template argument list.
48///
49/// \param RelativeToPrimary true if we should get the template
50/// arguments relative to the primary template, even when we're
51/// dealing with a specialization. This is only relevant for function
52/// template specializations.
53///
54/// \param Pattern If non-NULL, indicates the pattern from which we will be
55/// instantiating the definition of the given declaration, \p D. This is
56/// used to determine the proper set of template instantiation arguments for
57/// friend function template specializations.
58MultiLevelTemplateArgumentList
59Sema::getTemplateInstantiationArgs(NamedDecl *D,
                                 const TemplateArgumentList *Innermost,
                                 bool RelativeToPrimary,
                                 const FunctionDecl *Pattern) {
// Accumulate the set of template argument lists in this structure.
MultiLevelTemplateArgumentList Result;

if (Innermost)
  Result.addOuterTemplateArguments(Innermost);

DeclContext *Ctx = dyn_cast<DeclContext>(D);
if (!Ctx) {
  Ctx = D->getDeclContext();

  // Add template arguments from a variable template instantiation. For a
  // class-scope explicit specialization, there are no template arguments
  // at this level, but there may be enclosing template arguments.
  VarTemplateSpecializationDecl *Spec =
      dyn_cast<VarTemplateSpecializationDecl>(D);
  if (Spec && !Spec->isClassScopeExplicitSpecialization()) {
    // We're done when we hit an explicit specialization.
    if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
        !isa<VarTemplatePartialSpecializationDecl>(Spec))
      return Result;

    Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());

    // If this variable template specialization was instantiated from a
    // specialized member that is a variable template, we're done.
    assert(Spec->getSpecializedTemplate() && "No variable template?")((Spec->getSpecializedTemplate() && "No variable template?"
) ? static_cast<void> (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No variable template?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 88, __PRETTY_FUNCTION__));
    llvm::PointerUnion<VarTemplateDecl*,
                       VarTemplatePartialSpecializationDecl*> Specialized
                           = Spec->getSpecializedTemplateOrPartial();
    if (VarTemplatePartialSpecializationDecl *Partial =
            Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
      if (Partial->isMemberSpecialization())
        return Result;
    } else {
      VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
      if (Tmpl->isMemberSpecialization())
        return Result;
    }
  }

  // If we have a template template parameter with translation unit context,
  // then we're performing substitution into a default template argument of
  // this template template parameter before we've constructed the template
  // that will own this template template parameter. In this case, we
  // use empty template parameter lists for all of the outer templates
  // to avoid performing any substitutions.
  if (Ctx->isTranslationUnit()) {
    if (TemplateTemplateParmDecl *TTP
                                    = dyn_cast<TemplateTemplateParmDecl>(D)) {
      for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
        Result.addOuterTemplateArguments(None);
      return Result;
    }
  }
}

while (!Ctx->isFileContext()) {
  // Add template arguments from a class template instantiation.
  ClassTemplateSpecializationDecl *Spec
        = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
  if (Spec && !Spec->isClassScopeExplicitSpecialization()) {
    // We're done when we hit an explicit specialization.
    if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
        !isa<ClassTemplatePartialSpecializationDecl>(Spec))
      break;

    Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());

    // If this class template specialization was instantiated from a
    // specialized member that is a class template, we're done.
    assert(Spec->getSpecializedTemplate() && "No class template?")((Spec->getSpecializedTemplate() && "No class template?"
) ? static_cast<void> (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No class template?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 133, __PRETTY_FUNCTION__));
    if (Spec->getSpecializedTemplate()->isMemberSpecialization())
      break;
  }
  // Add template arguments from a function template specialization.
  else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
    if (!RelativeToPrimary &&
        Function->getTemplateSpecializationKindForInstantiation() ==
            TSK_ExplicitSpecialization)
      break;

    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.
    } else if (const TemplateArgumentList *TemplateArgs
          = Function->getTemplateSpecializationArgs()) {
      // Add the template arguments for this specialization.
      Result.addOuterTemplateArguments(TemplateArgs);

      // If this function was instantiated from a specialized member that is
      // a function template, we're done.
      assert(Function->getPrimaryTemplate() && "No function template?")((Function->getPrimaryTemplate() && "No function template?"
) ? static_cast<void> (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 156, __PRETTY_FUNCTION__));
      if (Function->getPrimaryTemplate()->isMemberSpecialization())
        break;

      // If this function is a generic lambda specialization, we are done.
      if (isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
        break;

    } else if (FunctionTemplateDecl *FunTmpl
                                 = Function->getDescribedFunctionTemplate()) {
      // Add the "injected" template arguments.
      Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs());
    }

    // If this is a friend 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->getDeclContext()->isFileContext() &&
        (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
      Ctx = Function->getLexicalDeclContext();
      RelativeToPrimary = false;
      continue;
    }
  } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
    if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
      QualType T = ClassTemplate->getInjectedClassNameSpecialization();
      const TemplateSpecializationType *TST =
          cast<TemplateSpecializationType>(Context.getCanonicalType(T));
      Result.addOuterTemplateArguments(
          llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
      if (ClassTemplate->isMemberSpecialization())
        break;
    }
  }

  Ctx = Ctx->getParent();
  RelativeToPrimary = false;
}

return Result;
198}

200bool 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 DefaultTemplateArgumentChecking:
case DeclaringSpecialMember:
case DeclaringImplicitEqualityComparison:
case DefiningSynthesizedFunction:
case ExceptionSpecEvaluation:
case ConstraintSubstitution:
case ParameterMappingSubstitution:
case ConstraintNormalization:
case RewritingOperatorAsSpaceship:
case InitializingStructuredBinding:
case MarkingClassDllexported:
  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!", "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 232);
233}

235Sema::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);
}
268}

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

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

284Sema::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) {}

294Sema::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(((Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? static_cast<void> (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 305, __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||((Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? static_cast<void> (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 305, __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)((Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? static_cast<void> (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 305, __PRETTY_FUNCTION__));
306}

308Sema::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) {}

319Sema::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) {}

330Sema::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) {}

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

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

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

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

379Sema::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=*/None, &DeductionInfo) {}


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


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

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

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

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

433void 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);
446}

448void Sema::popCodeSynthesisContext() {
auto &Active = CodeSynthesisContexts.back();
if (!Active.isInstantiationRecord()) {
  assert(NonInstantiationEntries > 0)((NonInstantiationEntries > 0) ? static_cast<void> (
0) : __assert_fail ("NonInstantiationEntries > 0", "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 451, __PRETTY_FUNCTION__));
  --NonInstantiationEntries;
}

InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;

// Name lookup no longer looks in this template's defining module.
assert(CodeSynthesisContexts.size() >=((CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules
.size() && "forgot to remove a lookup module for a template instantiation"
) ? static_cast<void> (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 460, __PRETTY_FUNCTION__))
           CodeSynthesisContextLookupModules.size() &&((CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules
.size() && "forgot to remove a lookup module for a template instantiation"
) ? static_cast<void> (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 460, __PRETTY_FUNCTION__))
       "forgot to remove a lookup module for a template instantiation")((CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules
.size() && "forgot to remove a lookup module for a template instantiation"
) ? static_cast<void> (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 460, __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();
475}

477void 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;
}
492}

494bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
                                      SourceLocation PointOfInstantiation,
                                         SourceRange InstantiationRange) {
assert(SemaRef.NonInstantiationEntries <=((SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts
.size()) ? static_cast<void> (0) : __assert_fail ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 498, __PRETTY_FUNCTION__))
       SemaRef.CodeSynthesisContexts.size())((SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts
.size()) ? static_cast<void> (0) : __assert_fail ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 498, __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;
511}

513/// Prints the current instantiation stack through a series of
514/// notes.
515void 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);
    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",
 "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 636);
      }

      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);
    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::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::Memoization:
    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))((isa<FunctionDecl>(Active->Entity)) ? static_cast<
void> (0) : __assert_fail ("isa<FunctionDecl>(Active->Entity)"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 802, __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);
    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;
  }
}
833}

835Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
if (InNonInstantiationSFINAEContext)
  return Optional<TemplateDeductionInfo *>(nullptr);

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;
    LLVM_FALLTHROUGH[[gnu::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 None;

  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:
  case CodeSynthesisContext::ConstraintSubstitution:
  case CodeSynthesisContext::RequirementInstantiation:
    // We're either substituting explicitly-specified template arguments,
    // deduced template arguments, a constraint expression or a requirement
    // in a requires expression, so SFINAE applies.
    assert(Active->DeductionInfo && "Missing deduction info pointer")((Active->DeductionInfo && "Missing deduction info pointer"
) ? static_cast<void> (0) : __assert_fail ("Active->DeductionInfo && \"Missing deduction info pointer\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 877, __PRETTY_FUNCTION__));
    return Active->DeductionInfo;

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

  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 Optional<TemplateDeductionInfo *>(nullptr);
}

return None;
906}

908//===----------------------------------------------------------------------===/
909// Template Instantiation for Types
910//===----------------------------------------------------------------------===/
911namespace {
class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
  const MultiLevelTemplateArgumentList &TemplateArgs;
  SourceLocation Loc;
  DeclarationName Entity;

public:
  typedef TreeTransform<TemplateInstantiator> inherited;

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

  /// 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);
  }

  bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
                               SourceRange PatternRange,
                               ArrayRef<UnexpandedParameterPack> Unexpanded,
                               bool &ShouldExpand, bool &RetainExpansion,
                               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()) {
      SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Old);
      for (auto *New : NewDecls)
        SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(
            Old, cast<VarDecl>(New));
      return;
    }

    assert(NewDecls.size() == 1 &&((NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? static_cast<void> (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1017, __PRETTY_FUNCTION__))
           "should only have multiple expansions for a pack")((NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? static_cast<void> (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1017, __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);
    if (NewMD && isLambdaCallOperator(NewMD)) {
      auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
      if (auto *NewTD = NewMD->getDescribedFunctionTemplate())
        NewTD->setInstantiatedFromMemberTemplate(
            OldMD->getDescribedFunctionTemplate());
      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))
      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);

  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,
                                          Optional<unsigned> NumExpansions,
                                          bool ExpectParameterPack);

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

  /// 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.
  QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                         SubstTemplateTypeParmPackTypeLoc TL);

  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
    return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E);
  }

  ExprResult TransformRequiresExpr(RequiresExpr *E) {
    LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
    return TreeTransform<TemplateInstantiator>::TransformRequiresExpr(E);
1
Calling 'TreeTransform::TransformRequiresExpr'→
  }

  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);
    return DeclInstantiator.SubstTemplateParams(OrigTPL);
  }

  concepts::TypeRequirement *
  TransformTypeRequirement(concepts::TypeRequirement *Req);
  concepts::ExprRequirement *
  TransformExprRequirement(concepts::ExprRequirement *Req);
  concepts::NestedRequirement *
  TransformNestedRequirement(concepts::NestedRequirement *Req);

private:
  ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
                                             SourceLocation loc,
                                             TemplateArgument arg);
};
1192}

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

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

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

1205static TemplateArgument
1206getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
assert(S.ArgumentPackSubstitutionIndex >= 0)((S.ArgumentPackSubstitutionIndex >= 0) ? static_cast<void
> (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1207, __PRETTY_FUNCTION__));
assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())((S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()) ?
 static_cast<void> (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1208, __PRETTY_FUNCTION__));
Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex];
if (Arg.isPackExpansion())
  Arg = Arg.getPackExpansionPattern();
return Arg;
1213}

1215Decl *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 &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1233, __PRETTY_FUNCTION__))
             "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1233, __PRETTY_FUNCTION__));
      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && Template.getAsTemplateDecl() &&((!Template.isNull() && Template.getAsTemplateDecl() &&
 "Wrong kind of template template argument") ? static_cast<
void> (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1239, __PRETTY_FUNCTION__))
           "Wrong kind of template template argument")((!Template.isNull() && Template.getAsTemplateDecl() &&
 "Wrong kind of template template argument") ? static_cast<
void> (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1239, __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);
1248}

1250Decl *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;
1257}

1259NamedDecl *
1260TemplateInstantiator::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 &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1274, __PRETTY_FUNCTION__))
             "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1274, __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));
1296}

1298VarDecl *
1299TemplateInstantiator::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;
1309}

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

1320QualType
1321TemplateInstantiator::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 TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc,
                                                                  Keyword,
                                                                QualifierLoc,
                                                                  T);
1351}

1353TemplateName 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() &&((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1375, __PRETTY_FUNCTION__))
               "unexpected pack arguments in template rewrite")((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1375, __PRETTY_FUNCTION__));
        Arg = Arg.pack_begin()->getPackExpansionPattern();
      }
      assert(Arg.getKind() == TemplateArgument::Template &&((Arg.getKind() == TemplateArgument::Template && "unexpected nontype template argument kind in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1379, __PRETTY_FUNCTION__))
             "unexpected nontype template argument kind in template rewrite")((Arg.getKind() == TemplateArgument::Template && "unexpected nontype template argument kind in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1379, __PRETTY_FUNCTION__));
      return Arg.getAsTemplate();
    }

    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1385, __PRETTY_FUNCTION__))
             "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1385, __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(TTP, Arg);
      }

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

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && "Null template template argument")((!Template.isNull() && "Null template template argument"
) ? static_cast<void> (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1398, __PRETTY_FUNCTION__));
    assert(!Template.getAsQualifiedTemplateName() &&((!Template.getAsQualifiedTemplateName() && "template decl to substitute is qualified?"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1400, __PRETTY_FUNCTION__))
           "template decl to substitute is qualified?")((!Template.getAsQualifiedTemplateName() && "template decl to substitute is qualified?"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1400, __PRETTY_FUNCTION__));

    Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
    return Template;
  }
}

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

  TemplateArgument Arg = SubstPack->getArgumentPack();
  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
  return Arg.getAsTemplate().getNameToSubstitute();
}

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

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

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

1430ExprResult
1431TemplateInstantiator::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() &&((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1448, __PRETTY_FUNCTION__))
           "unexpected pack arguments in template rewrite")((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1448, __PRETTY_FUNCTION__));
    Arg = Arg.pack_begin()->getPackExpansionPattern();
  }
  assert(Arg.getKind() == TemplateArgument::Expression &&((Arg.getKind() == TemplateArgument::Expression && "unexpected nontype template argument kind in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1452, __PRETTY_FUNCTION__))
         "unexpected nontype template argument kind in template rewrite")((Arg.getKind() == TemplateArgument::Expression && "unexpected nontype template argument kind in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1452, __PRETTY_FUNCTION__));
  // FIXME: This can lead to the same subexpression appearing multiple times
  // in a complete expression.
  return Arg.getAsExpr();
}

if (NTTP->isParameterPack()) {
  assert(Arg.getKind() == TemplateArgument::Pack &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1460, __PRETTY_FUNCTION__))
         "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1460, __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();

    return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
        ExprType, TargetType->isReferenceType() ? VK_LValue : VK_RValue, NTTP,
        E->getLocation(), Arg);
  }

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

return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1485}

1487const LoopHintAttr *
1488TemplateInstantiator::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);
1502}

1504ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
                                               NonTypeTemplateParmDecl *parm,
                                               SourceLocation loc,
                                               TemplateArgument arg) {
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")((!paramType.isNull() && "type substitution failed for param type"
) ? static_cast<void> (0) : __assert_fail ("!paramType.isNull() && \"type substitution failed for param type\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1560, __PRETTY_FUNCTION__));
  assert(!paramType->isDependentType() && "param type still dependent")((!paramType->isDependentType() && "param type still dependent"
) ? static_cast<void> (0) : __assert_fail ("!paramType->isDependentType() && \"param type still dependent\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1561, __PRETTY_FUNCTION__));
  result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, paramType, loc);
  refParam = paramType->isReferenceType();
} else {
  result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
  assert(result.isInvalid() ||((result.isInvalid() || SemaRef.Context.hasSameType(result.get
()->getType(), arg.getIntegralType())) ? static_cast<void
> (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1568, __PRETTY_FUNCTION__))
         SemaRef.Context.hasSameType(result.get()->getType(),((result.isInvalid() || SemaRef.Context.hasSameType(result.get
()->getType(), arg.getIntegralType())) ? static_cast<void
> (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1568, __PRETTY_FUNCTION__))
                                     arg.getIntegralType()))((result.isInvalid() || SemaRef.Context.hasSameType(result.get
()->getType(), arg.getIntegralType())) ? static_cast<void
> (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1568, __PRETTY_FUNCTION__));
}

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

Expr *resultExpr = result.get();
return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
    resultExpr->getType(), resultExpr->getValueKind(), loc, parm, refParam,
    resultExpr);
1578}

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

TemplateArgument Arg = E->getArgumentPack();
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
return transformNonTypeTemplateParmRef(E->getParameterPack(),
                                       E->getParameterPackLocation(),
                                       Arg);
1593}

1595ExprResult
1596TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
                                        SubstNonTypeTemplateParmExpr *E) {
ExprResult 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 Converted;
if (SemaRef.CheckTemplateArgument(E->getParameter(), SubstType,
                                  SubstReplacement.get(),
                                  Converted).isInvalid())
  return true;
return transformNonTypeTemplateParmRef(E->getParameter(),
                                       E->getExprLoc(), Converted);
1631}

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

1639ExprResult
1640TemplateInstantiator::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;
1671}

1673ExprResult
1674TemplateInstantiator::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")((Found && "no instantiation for parameter pack") ? static_cast
<void> (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1679, __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());
1702}

1704ExprResult
1705TemplateInstantiator::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 TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E);
1724}

1726ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
  CXXDefaultArgExpr *E) {
assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->((!cast<FunctionDecl>(E->getParam()->getDeclContext
())-> getDescribedFunctionTemplate() && "Default arg expressions are never formed in dependent cases."
) ? static_cast<void> (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1730, __PRETTY_FUNCTION__))
           getDescribedFunctionTemplate() &&((!cast<FunctionDecl>(E->getParam()->getDeclContext
())-> getDescribedFunctionTemplate() && "Default arg expressions are never formed in dependent cases."
) ? static_cast<void> (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1730, __PRETTY_FUNCTION__))
       "Default arg expressions are never formed in dependent cases.")((!cast<FunctionDecl>(E->getParam()->getDeclContext
())-> getDescribedFunctionTemplate() && "Default arg expressions are never formed in dependent cases."
) ? static_cast<void> (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1730, __PRETTY_FUNCTION__));
return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
                         cast<FunctionDecl>(E->getParam()->getDeclContext()),
                                      E->getParam());
1734}

1736template<typename Fn>
1737QualType 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);
1746}

1748ParmVarDecl *
1749TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                               int indexAdjustment,
                                             Optional<unsigned> NumExpansions,
                                               bool ExpectParameterPack) {
auto NewParm =
    SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
                             NumExpansions, ExpectParameterPack);
if (NewParm && SemaRef.getLangOpts().OpenCL)
  SemaRef.deduceOpenCLAddressSpace(NewParm);
return NewParm;
1759}

1761QualType
1762TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                              TemplateTypeParmTypeLoc TL) {
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() &&((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1787, __PRETTY_FUNCTION__))
             "unexpected pack arguments in template rewrite")((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1787, __PRETTY_FUNCTION__));
      Arg = Arg.pack_begin()->getPackExpansionPattern();
    }
    assert(Arg.getKind() == TemplateArgument::Type &&((Arg.getKind() == TemplateArgument::Type && "unexpected nontype template argument kind in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1791, __PRETTY_FUNCTION__))
           "unexpected nontype template argument kind in template rewrite")((Arg.getKind() == TemplateArgument::Type && "unexpected nontype template argument kind in template rewrite"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1791, __PRETTY_FUNCTION__));
    QualType NewT = Arg.getAsType();
    assert(isa<TemplateTypeParmType>(NewT) &&((isa<TemplateTypeParmType>(NewT) && "type parm not rewritten to type parm"
) ? static_cast<void> (0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1794, __PRETTY_FUNCTION__))
           "type parm not rewritten to type parm")((isa<TemplateTypeParmType>(NewT) && "type parm not rewritten to type parm"
) ? static_cast<void> (0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1794, __PRETTY_FUNCTION__));
    auto NewTL = TLB.push<TemplateTypeParmTypeLoc>(NewT);
    NewTL.setNameLoc(TL.getNameLoc());
    return NewT;
  }

  if (T->isParameterPack()) {
    assert(Arg.getKind() == TemplateArgument::Pack &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1802, __PRETTY_FUNCTION__))
           "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1802, __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(T, Arg);
      SubstTemplateTypeParmPackTypeLoc NewTL
        = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
      NewTL.setNameLoc(TL.getNameLoc());
      return Result;
    }

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

  assert(Arg.getKind() == TemplateArgument::Type &&((Arg.getKind() == TemplateArgument::Type && "Template argument kind mismatch"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1820, __PRETTY_FUNCTION__))
         "Template argument kind mismatch")((Arg.getKind() == TemplateArgument::Type && "Template argument kind mismatch"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1820, __PRETTY_FUNCTION__));

  QualType Replacement = Arg.getAsType();

  // TODO: only do this uniquing once, at the start of instantiation.
  QualType Result
    = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
  SubstTemplateTypeParmTypeLoc NewTL
    = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
  return Result;
}

// 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;
1848}

1850QualType
1851TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
                                                          TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmPackTypeLoc TL) {
if (getSema().ArgumentPackSubstitutionIndex == -1) {
  // We aren't expanding the parameter pack, so just return ourselves.
  SubstTemplateTypeParmPackTypeLoc NewTL
    = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType());
  NewTL.setNameLoc(TL.getNameLoc());
  return TL.getType();
}

TemplateArgument Arg = TL.getTypePtr()->getArgumentPack();
Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
QualType Result = Arg.getAsType();

Result = getSema().Context.getSubstTemplateTypeParmType(
                                    TL.getTypePtr()->getReplacedParameter(),
                                                        Result);
SubstTemplateTypeParmTypeLoc NewTL
  = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
1873}

1875template<typename EntityPrinter>
1876static concepts::Requirement::SubstitutionDiagnostic *
1877createSubstDiag(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())};
1899}

1901concepts::TypeRequirement *
1902TemplateInstantiator::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);
1926}

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

Sema::SFINAETrap Trap(SemaRef);
TemplateDeductionInfo Info(Req->getExpr()->getBeginLoc());

llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
    TransExpr;
if (Req->isExprSubstitutionFailure())
  TransExpr = Req->getExprSubstitutionDiagnostic();
else {
  Sema::InstantiatingTemplate ExprInst(SemaRef, Req->getExpr()->getBeginLoc(),
                                       Req, Info,
                                       Req->getExpr()->getSourceRange());
  if (ExprInst.isInvalid())
    return nullptr;
  ExprResult TransExprRes = TransformExpr(Req->getExpr());
  if (TransExprRes.isInvalid() || Trap.hasErrorOccurred())
    TransExpr = createSubstDiag(SemaRef, Info,
        [&] (llvm::raw_ostream& OS) {
            Req->getExpr()->printPretty(OS, nullptr,
                                        SemaRef.getPrintingPolicy());
        });
  else
    TransExpr = TransExprRes.get();
}

llvm::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();
  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.hasValue() &&((TransRetReq.hasValue() && "All code paths leading here must set TransRetReq"
) ? static_cast<void> (0) : __assert_fail ("TransRetReq.hasValue() && \"All code paths leading here must set TransRetReq\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1984, __PRETTY_FUNCTION__))
       "All code paths leading here must set TransRetReq")((TransRetReq.hasValue() && "All code paths leading here must set TransRetReq"
) ? static_cast<void> (0) : __assert_fail ("TransRetReq.hasValue() && \"All code paths leading here must set TransRetReq\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1984, __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));
1991}

1993concepts::NestedRequirement *
1994TemplateInstantiator::TransformNestedRequirement(
  concepts::NestedRequirement *Req) {
if (!Req->isDependent() && !AlwaysRebuild())
  return Req;
if (Req->isSubstitutionFailure()) {
  if (AlwaysRebuild())
    return RebuildNestedRequirement(
        Req->getSubstitutionDiagnostic());
  return Req;
}
Sema::InstantiatingTemplate ReqInst(SemaRef,
    Req->getConstraintExpr()->getBeginLoc(), Req,
    Sema::InstantiatingTemplate::ConstraintsCheck{},
    Req->getConstraintExpr()->getSourceRange());

ExprResult TransConstraint;
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;
  TransConstraint = TransformExpr(Req->getConstraintExpr());
  if (TransConstraint.isInvalid() || Trap.hasErrorOccurred())
    return RebuildNestedRequirement(createSubstDiag(SemaRef, Info,
        [&] (llvm::raw_ostream& OS) {
            Req->getConstraintExpr()->printPretty(OS, nullptr,
                                                  SemaRef.getPrintingPolicy());
        }));
}
return RebuildNestedRequirement(TransConstraint.get());
2029}


2032/// Perform substitution on the type T with a given set of template
2033/// arguments.
2034///
2035/// This routine substitutes the given template arguments into the
2036/// type T and produces the instantiated type.
2037///
2038/// \param T the type into which the template arguments will be
2039/// substituted. If this type is not dependent, it will be returned
2040/// immediately.
2041///
2042/// \param Args the template arguments that will be
2043/// substituted for the top-level template parameters within T.
2044///
2045/// \param Loc the location in the source code where this substitution
2046/// is being performed. It will typically be the location of the
2047/// declarator (if we're instantiating the type of some declaration)
2048/// or the location of the type in the source code (if, e.g., we're
2049/// instantiating the type of a cast expression).
2050///
2051/// \param Entity the name of the entity associated with a declaration
2052/// being instantiated (if any). May be empty to indicate that there
2053/// is no such entity (if, e.g., this is a type that occurs as part of
2054/// a cast expression) or that the entity has no name (e.g., an
2055/// unnamed function parameter).
2056///
2057/// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
2058/// acceptable as the top level type of the result.
2059///
2060/// \returns If the instantiation succeeds, the instantiated
2061/// type. Otherwise, produces diagnostics and returns a NULL type.
2062TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              bool AllowDeducedTST) {
assert(!CodeSynthesisContexts.empty() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2069, __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2069, __PRETTY_FUNCTION__))
       "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2069, __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);
2078}

2080TypeSourceInfo *Sema::SubstType(TypeLoc TL,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2086, __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2086, __PRETTY_FUNCTION__))
       "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2086, __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);
2108}

2110/// Deprecated form of the above.
2111QualType Sema::SubstType(QualType T,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SourceLocation Loc, DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2116, __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2116, __PRETTY_FUNCTION__))
       "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2116, __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);
2125}

2127static 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;
2147}

2149/// A form of SubstType intended specifically for instantiating the
2150/// type of a FunctionDecl.  Its purpose is solely to force the
2151/// instantiation of default-argument expressions and to avoid
2152/// instantiating an exception-specification.
2153TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              CXXRecordDecl *ThisContext,
                              Qualifiers ThisTypeQuals) {
assert(!CodeSynthesisContexts.empty() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2161, __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2161, __PRETTY_FUNCTION__))
       "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2161, __PRETTY_FUNCTION__));

if (!NeedsInstantiationAsFunctionType(T))
  return T;

TemplateInstantiator Instantiator(*this, Args, Loc, Entity);

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);
2193}

2195bool Sema::SubstExceptionSpec(SourceLocation Loc,
                            FunctionProtoType::ExceptionSpecInfo &ESI,
                            SmallVectorImpl<QualType> &ExceptionStorage,
                            const MultiLevelTemplateArgumentList &Args) {
assert(ESI.Type != EST_Uninstantiated)((ESI.Type != EST_Uninstantiated) ? static_cast<void> (
0) : __assert_fail ("ESI.Type != EST_Uninstantiated", "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2199, __PRETTY_FUNCTION__));

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

2207void 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);
2219}

2221namespace {

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());
  }
};

2307} // namespace

2309ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
                                  int indexAdjustment,
                                  Optional<unsigned> NumExpansions,
                                  bool ExpectParameterPack) {
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()) {
      // TODO: Concepts: do not instantiate the constraint (delayed constraint
      // substitution)
      const ASTTemplateArgumentListInfo *TemplArgInfo
        = TC->getTemplateArgsAsWritten();
      TemplateArgumentListInfo InstArgs;

      if (TemplArgInfo) {
        InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
        InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
        if (Subst(TemplArgInfo->getTemplateArgs(),
                  TemplArgInfo->NumTemplateArgs, InstArgs, TemplateArgs))
          return nullptr;
      }
      if (AttachTypeConstraint(
              TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
              TC->getNamedConcept(), &InstArgs, Inst,
              TTP->isParameterPack()
                  ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
                      ->getEllipsisLoc()
                  : SourceLocation()))
        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()) {
  FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext());
  if (OwningFunc->isInLocalScopeForInstantiation()) {
    // Instantiate default arguments for methods of local classes (DR1484)
    // and non-defining declarations.
    Sema::ContextRAII SavedContext(*this, OwningFunc);
    LocalInstantiationScope Local(*this, true);
    ExprResult NewArg = SubstExpr(Arg, TemplateArgs);
    if (NewArg.isUsable()) {
      // It would be nice if we still had this.
      SourceLocation EqualLoc = NewArg.get()->getBeginLoc();
      ExprResult Result =
          ConvertParamDefaultArgument(NewParm, NewArg.get(), EqualLoc);
      if (Result.isInvalid())
        return nullptr;

      SetParamDefaultArgument(NewParm, Result.getAs<Expr>(), EqualLoc);
    }
  } else {
    // FIXME: if we non-lazily instantiated non-dependent default args for
    // non-dependent parameter types we could remove a bunch of duplicate
    // conversion warnings for such arguments.
    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;
2458}

2460/// Substitute the given template arguments into the given set of
2461/// parameters, producing the set of parameter types that would be generated
2462/// from such a substitution.
2463bool 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() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2472, __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2472, __PRETTY_FUNCTION__))
       "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? static_cast<void> (0) : __assert_fail
 ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2472, __PRETTY_FUNCTION__));

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

2480/// Perform substitution on the base class specifiers of the
2481/// given class template specialization.
2482///
2483/// Produces a diagnostic and returns true on error, returns false and
2484/// attaches the instantiated base classes to the class template
2485/// specialization if successful.
2486bool
2487Sema::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;
    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;
2587}

2589// Defined via #include from SemaTemplateInstantiateDecl.cpp
2590namespace 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);
}
2598}

2600/// Instantiate the definition of a class from a given pattern.
2601///
2602/// \param PointOfInstantiation The point of instantiation within the
2603/// source code.
2604///
2605/// \param Instantiation is the declaration whose definition is being
2606/// instantiated. This will be either a class template specialization
2607/// or a member class of a class template specialization.
2608///
2609/// \param Pattern is the pattern from which the instantiation
2610/// occurs. This will be either the declaration of a class template or
2611/// the declaration of a member class of a class template.
2612///
2613/// \param TemplateArgs The template arguments to be substituted into
2614/// the pattern.
2615///
2616/// \param TSK the kind of implicit or explicit instantiation to perform.
2617///
2618/// \param Complain whether to complain if the class cannot be instantiated due
2619/// to the lack of a definition.
2620///
2621/// \returns true if an error occurred, false otherwise.
2622bool
2623Sema::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")((!Inst.isAlreadyInstantiating() && "should have been caught by caller"
) ? static_cast<void> (0) : __assert_fail ("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2659, __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);
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")((MSInfo && "no spec info for member enum specialization"
) ? static_cast<void> (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2743, __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())((CurrentInstantiationScope == Instantiator.getStartingScope(
)) ? static_cast<void> (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2785, __PRETTY_FUNCTION__));
  CurrentInstantiationScope = I->Scope;

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

  Attr *NewAttr =
    instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
  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.
  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();
2863}

2865/// Instantiate the definition of an enum from a given pattern.
2866///
2867/// \param PointOfInstantiation The point of instantiation within the
2868///        source code.
2869/// \param Instantiation is the declaration whose definition is being
2870///        instantiated. This will be a member enumeration of a class
2871///        temploid specialization, or a local enumeration within a
2872///        function temploid specialization.
2873/// \param Pattern The templated declaration from which the instantiation
2874///        occurs.
2875/// \param TemplateArgs The template arguments to be substituted into
2876///        the pattern.
2877/// \param TSK The kind of implicit or explicit instantiation to perform.
2878///
2879/// \return \c true if an error occurred, \c false otherwise.
2880bool 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();
2928}


2931/// Instantiate the definition of a field from the given pattern.
2932///
2933/// \param PointOfInstantiation The point of instantiation within the
2934///        source code.
2935/// \param Instantiation is the declaration whose definition is being
2936///        instantiated. This will be a class of a class temploid
2937///        specialization, or a local enumeration within a function temploid
2938///        specialization.
2939/// \param Pattern The templated declaration from which the instantiation
2940///        occurs.
2941/// \param TemplateArgs The template arguments to be substituted into
2942///        the pattern.
2943///
2944/// \return \c true if an error occurred, \c false otherwise.
2945bool 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() ==((Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle
() && "pattern and instantiation disagree about init style"
) ? static_cast<void> (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2954, __PRETTY_FUNCTION__))
           Pattern->getInClassInitStyle() &&((Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle
() && "pattern and instantiation disagree about init style"
) ? static_cast<void> (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2954, __PRETTY_FUNCTION__))
       "pattern and instantiation disagree about init style")((Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle
() && "pattern and instantiation disagree about init style"
) ? static_cast<void> (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2954, __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);

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")(((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class"
) ? static_cast<void> (0) : __assert_fail ("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2998, __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();
3007}

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

3018bool 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;
3035}

3037/// Get the instantiation pattern to use to instantiate the definition of a
3038/// given ClassTemplateSpecializationDecl (either the pattern of the primary
3039/// template or of a partial specialization).
3040static ActionResult<CXXRecordDecl *>
3041getPatternForClassTemplateSpecialization(
  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.take();
    }
  }

  // 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;
3185}

3187bool 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);
3206}

3208/// Instantiates the definitions of all of the member
3209/// of the given class, which is an instantiation of a class template
3210/// or a member class of a template.
3211void
3212Sema::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((((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
 || (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3223, __PRETTY_FUNCTION__))
    (TSK == TSK_ExplicitInstantiationDefinition ||(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
 || (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3223, __PRETTY_FUNCTION__))
     TSK == TSK_ExplicitInstantiationDeclaration ||(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
 || (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3223, __PRETTY_FUNCTION__))
     (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
 || (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3223, __PRETTY_FUNCTION__))
    "Unexpected template specialization kind!")(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
 || (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3223, __PRETTY_FUNCTION__));
for (auto *D : Instantiation->decls()) {
  bool SuppressNew = false;
  if (auto *Function = dyn_cast<FunctionDecl>(D)) {
    if (FunctionDecl *Pattern =
            Function->getInstantiatedFromMemberFunction()) {

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

      MemberSpecializationInfo *MSInfo =
          Function->getMemberSpecializationInfo();
      assert(MSInfo && "No member specialization information?")((MSInfo && "No member specialization information?") ?
 static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3235, __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?")((MSInfo && "No member specialization information?") ?
 static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3279, __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?")((MSInfo && "No member specialization information?") ?
 static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3322, __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")((Pattern && "Missing instantiated-from-template information"
) ? static_cast<void> (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3348, __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?")((MSInfo && "No member specialization information?") ?
 static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3384, __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")((Pattern && "Missing instantiated-from-template information"
) ? static_cast<void> (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3401, __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 = cast<FieldDecl>(Lookup.front());
      InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
                                    TemplateArgs);
    }
  }
}
3426}

3428/// Instantiate the definitions of all of the members of the
3429/// given class template specialization, which was named as part of an
3430/// explicit instantiation.
3431void
3432Sema::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);
3447}

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

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

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

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

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

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

3491bool 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);
3502}

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

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

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

3524TemplateName
3525Sema::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);
3533}

3535bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
               TemplateArgumentListInfo &Result,
               const MultiLevelTemplateArgumentList &TemplateArgs) {
TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                  DeclarationName());

return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
3542}

3544static 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;
3559}


3562llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
3563LocalInstantiationScope::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")((isa<LabelDecl>(D) && "declaration not instantiated in this scope"
) ? static_cast<void> (0) : __assert_fail ("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3613, __PRETTY_FUNCTION__));
return nullptr;
3615}

3617void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
D = getCanonicalParmVarDecl(D);
llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
if (Stored.isNull()) {
3621#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() &&((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Instantiated local in inner and outer scopes")
 ? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3627, __PRETTY_FUNCTION__))
           "Instantiated local in inner and outer scopes")((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Instantiated local in inner and outer scopes")
 ? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3627, __PRETTY_FUNCTION__));
  }
3629#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")((Stored.get<Decl *>() == Inst && "Already instantiated this local"
) ? static_cast<void> (0) : __assert_fail ("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3634, __PRETTY_FUNCTION__));
}
3636}

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

3645void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
3646#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() &&((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Creating local pack after instantiation of local"
) ? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3651, __PRETTY_FUNCTION__))
         "Creating local pack after instantiation of local")((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Creating local pack after instantiation of local"
) ? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3651, __PRETTY_FUNCTION__));
3652#endif

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

3661bool LocalInstantiationScope::isLocalPackExpansion(const Decl *D) {
for (DeclArgumentPack *Pack : ArgumentPacks)
  if (std::find(Pack->begin(), Pack->end(), D) != Pack->end())
    return true;
return false;
3666}

3668void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
                                        const TemplateArgument *ExplicitArgs,
                                                  unsigned NumExplicitArgs) {
assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack
) && "Already have a partially-substituted pack") ? static_cast
<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3672, __PRETTY_FUNCTION__))
       "Already have a partially-substituted pack")(((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack
) && "Already have a partially-substituted pack") ? static_cast
<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3672, __PRETTY_FUNCTION__));
assert((!PartiallySubstitutedPack(((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? static_cast<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3675, __PRETTY_FUNCTION__))
        || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? static_cast<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3675, __PRETTY_FUNCTION__))
       "Wrong number of arguments in partially-substituted pack")(((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
 == NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? static_cast<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3675, __PRETTY_FUNCTION__));
PartiallySubstitutedPack = Pack;
ArgsInPartiallySubstitutedPack = ExplicitArgs;
NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
3679}

3681NamedDecl *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;
3705}

←

/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/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	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14	#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15
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/ExprConcepts.h"
23	#include "clang/AST/ExprCXX.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/Lookup.h"
35	#include "clang/Sema/Ownership.h"
36	#include "clang/Sema/ParsedTemplate.h"
37	#include "clang/Sema/ScopeInfo.h"
38	#include "clang/Sema/SemaDiagnostic.h"
39	#include "clang/Sema/SemaInternal.h"
40	#include "llvm/ADT/ArrayRef.h"
41	#include "llvm/Support/ErrorHandling.h"
42	#include <algorithm>
43
44	using namespace llvm::omp;
45
46	namespace clang {
47	using namespace sema;
48
49	/// A semantic tree transformation that allows one to transform one
50	/// abstract syntax tree into another.
51	///
52	/// A new tree transformation is defined by creating a new subclass \c X of
53	/// \c TreeTransform<X> and then overriding certain operations to provide
54	/// behavior specific to that transformation. For example, template
55	/// instantiation is implemented as a tree transformation where the
56	/// transformation of TemplateTypeParmType nodes involves substituting the
57	/// template arguments for their corresponding template parameters; a similar
58	/// transformation is performed for non-type template parameters and
59	/// template template parameters.
60	///
61	/// This tree-transformation template uses static polymorphism to allow
62	/// subclasses to customize any of its operations. Thus, a subclass can
63	/// override any of the transformation or rebuild operators by providing an
64	/// operation with the same signature as the default implementation. The
65	/// overriding function should not be virtual.
66	///
67	/// Semantic tree transformations are split into two stages, either of which
68	/// can be replaced by a subclass. The "transform" step transforms an AST node
69	/// or the parts of an AST node using the various transformation functions,
70	/// then passes the pieces on to the "rebuild" step, which constructs a new AST
71	/// node of the appropriate kind from the pieces. The default transformation
72	/// routines recursively transform the operands to composite AST nodes (e.g.,
73	/// the pointee type of a PointerType node) and, if any of those operand nodes
74	/// were changed by the transformation, invokes the rebuild operation to create
75	/// a new AST node.
76	///
77	/// Subclasses can customize the transformation at various levels. The
78	/// most coarse-grained transformations involve replacing TransformType(),
79	/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
80	/// TransformTemplateName(), or TransformTemplateArgument() with entirely
81	/// new implementations.
82	///
83	/// For more fine-grained transformations, subclasses can replace any of the
84	/// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
85	/// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
86	/// replacing TransformTemplateTypeParmType() allows template instantiation
87	/// to substitute template arguments for their corresponding template
88	/// parameters. Additionally, subclasses can override the \c RebuildXXX
89	/// functions to control how AST nodes are rebuilt when their operands change.
90	/// By default, \c TreeTransform will invoke semantic analysis to rebuild
91	/// AST nodes. However, certain other tree transformations (e.g, cloning) may
92	/// be able to use more efficient rebuild steps.
93	///
94	/// There are a handful of other functions that can be overridden, allowing one
95	/// to avoid traversing nodes that don't need any transformation
96	/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
97	/// operands have not changed (\c AlwaysRebuild()), and customize the
98	/// default locations and entity names used for type-checking
99	/// (\c getBaseLocation(), \c getBaseEntity()).
100	template<typename Derived>
101	class TreeTransform {
102	/// Private RAII object that helps us forget and then re-remember
103	/// the template argument corresponding to a partially-substituted parameter
104	/// pack.
105	class ForgetPartiallySubstitutedPackRAII {
106	Derived &Self;
107	TemplateArgument Old;
108
109	public:
110	ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
111	Old = Self.ForgetPartiallySubstitutedPack();
112	}
113
114	~ForgetPartiallySubstitutedPackRAII() {
115	Self.RememberPartiallySubstitutedPack(Old);
116	}
117	};
118
119	protected:
120	Sema &SemaRef;
121
122	/// The set of local declarations that have been transformed, for
123	/// cases where we are forced to build new declarations within the transformer
124	/// rather than in the subclass (e.g., lambda closure types).
125	llvm::DenseMap<Decl , Decl > TransformedLocalDecls;
126
127	public:
128	/// Initializes a new tree transformer.
129	TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
130
131	/// Retrieves a reference to the derived class.
132	Derived &getDerived() { return static_cast<Derived&>(*this); }
133
134	/// Retrieves a reference to the derived class.
135	const Derived &getDerived() const {
136	return static_cast<const Derived&>(*this);
137	}
138
139	static inline ExprResult Owned(Expr *E) { return E; }
140	static inline StmtResult Owned(Stmt *S) { return S; }
141
142	/// Retrieves a reference to the semantic analysis object used for
143	/// this tree transform.
144	Sema &getSema() const { return SemaRef; }
145
146	/// Whether the transformation should always rebuild AST nodes, even
147	/// if none of the children have changed.
148	///
149	/// Subclasses may override this function to specify when the transformation
150	/// should rebuild all AST nodes.
151	///
152	/// We must always rebuild all AST nodes when performing variadic template
153	/// pack expansion, in order to avoid violating the AST invariant that each
154	/// statement node appears at most once in its containing declaration.
155	bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }
156
157	/// Whether the transformation is forming an expression or statement that
158	/// replaces the original. In this case, we'll reuse mangling numbers from
159	/// existing lambdas.
160	bool ReplacingOriginal() { return false; }
161
162	/// Wether CXXConstructExpr can be skipped when they are implicit.
163	/// They will be reconstructed when used if needed.
164	/// This is usefull when the user that cause rebuilding of the
165	/// CXXConstructExpr is outside of the expression at which the TreeTransform
166	/// started.
167	bool AllowSkippingCXXConstructExpr() { return true; }
168
169	/// Returns the location of the entity being transformed, if that
170	/// information was not available elsewhere in the AST.
171	///
172	/// By default, returns no source-location information. Subclasses can
173	/// provide an alternative implementation that provides better location
174	/// information.
175	SourceLocation getBaseLocation() { return SourceLocation(); }
176
177	/// Returns the name of the entity being transformed, if that
178	/// information was not available elsewhere in the AST.
179	///
180	/// By default, returns an empty name. Subclasses can provide an alternative
181	/// implementation with a more precise name.
182	DeclarationName getBaseEntity() { return DeclarationName(); }
183
184	/// Sets the "base" location and entity when that
185	/// information is known based on another transformation.
186	///
187	/// By default, the source location and entity are ignored. Subclasses can
188	/// override this function to provide a customized implementation.
189	void setBase(SourceLocation Loc, DeclarationName Entity) { }
190
191	/// RAII object that temporarily sets the base location and entity
192	/// used for reporting diagnostics in types.
193	class TemporaryBase {
194	TreeTransform &Self;
195	SourceLocation OldLocation;
196	DeclarationName OldEntity;
197
198	public:
199	TemporaryBase(TreeTransform &Self, SourceLocation Location,
200	DeclarationName Entity) : Self(Self) {
201	OldLocation = Self.getDerived().getBaseLocation();
202	OldEntity = Self.getDerived().getBaseEntity();
203
204	if (Location.isValid())
205	Self.getDerived().setBase(Location, Entity);
206	}
207
208	~TemporaryBase() {
209	Self.getDerived().setBase(OldLocation, OldEntity);
210	}
211	};
212
213	/// Determine whether the given type \p T has already been
214	/// transformed.
215	///
216	/// Subclasses can provide an alternative implementation of this routine
217	/// to short-circuit evaluation when it is known that a given type will
218	/// not change. For example, template instantiation need not traverse
219	/// non-dependent types.
220	bool AlreadyTransformed(QualType T) {
221	return T.isNull();
222	}
223
224	/// Transform a template parameter depth level.
225	///
226	/// During a transformation that transforms template parameters, this maps
227	/// an old template parameter depth to a new depth.
228	unsigned TransformTemplateDepth(unsigned Depth) {
229	return Depth;
230	}
231
232	/// Determine whether the given call argument should be dropped, e.g.,
233	/// because it is a default argument.
234	///
235	/// Subclasses can provide an alternative implementation of this routine to
236	/// determine which kinds of call arguments get dropped. By default,
237	/// CXXDefaultArgument nodes are dropped (prior to transformation).
238	bool DropCallArgument(Expr *E) {
239	return E->isDefaultArgument();
240	}
241
242	/// Determine whether we should expand a pack expansion with the
243	/// given set of parameter packs into separate arguments by repeatedly
244	/// transforming the pattern.
245	///
246	/// By default, the transformer never tries to expand pack expansions.
247	/// Subclasses can override this routine to provide different behavior.
248	///
249	/// \param EllipsisLoc The location of the ellipsis that identifies the
250	/// pack expansion.
251	///
252	/// \param PatternRange The source range that covers the entire pattern of
253	/// the pack expansion.
254	///
255	/// \param Unexpanded The set of unexpanded parameter packs within the
256	/// pattern.
257	///
258	/// \param ShouldExpand Will be set to \c true if the transformer should
259	/// expand the corresponding pack expansions into separate arguments. When
260	/// set, \c NumExpansions must also be set.
261	///
262	/// \param RetainExpansion Whether the caller should add an unexpanded
263	/// pack expansion after all of the expanded arguments. This is used
264	/// when extending explicitly-specified template argument packs per
265	/// C++0x [temp.arg.explicit]p9.
266	///
267	/// \param NumExpansions The number of separate arguments that will be in
268	/// the expanded form of the corresponding pack expansion. This is both an
269	/// input and an output parameter, which can be set by the caller if the
270	/// number of expansions is known a priori (e.g., due to a prior substitution)
271	/// and will be set by the callee when the number of expansions is known.
272	/// The callee must set this value when \c ShouldExpand is \c true; it may
273	/// set this value in other cases.
274	///
275	/// \returns true if an error occurred (e.g., because the parameter packs
276	/// are to be instantiated with arguments of different lengths), false
277	/// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
278	/// must be set.
279	bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
280	SourceRange PatternRange,
281	ArrayRef<UnexpandedParameterPack> Unexpanded,
282	bool &ShouldExpand,
283	bool &RetainExpansion,
284	Optional<unsigned> &NumExpansions) {
285	ShouldExpand = false;
286	return false;
287	}
288
289	/// "Forget" about the partially-substituted pack template argument,
290	/// when performing an instantiation that must preserve the parameter pack
291	/// use.
292	///
293	/// This routine is meant to be overridden by the template instantiator.
294	TemplateArgument ForgetPartiallySubstitutedPack() {
295	return TemplateArgument();
296	}
297
298	/// "Remember" the partially-substituted pack template argument
299	/// after performing an instantiation that must preserve the parameter pack
300	/// use.
301	///
302	/// This routine is meant to be overridden by the template instantiator.
303	void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
304
305	/// Note to the derived class when a function parameter pack is
306	/// being expanded.
307	void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
308
309	/// Transforms the given type into another type.
310	///
311	/// By default, this routine transforms a type by creating a
312	/// TypeSourceInfo for it and delegating to the appropriate
313	/// function. This is expensive, but we don't mind, because
314	/// this method is deprecated anyway; all users should be
315	/// switched to storing TypeSourceInfos.
316	///
317	/// \returns the transformed type.
318	QualType TransformType(QualType T);
319
320	/// Transforms the given type-with-location into a new
321	/// type-with-location.
322	///
323	/// By default, this routine transforms a type by delegating to the
324	/// appropriate TransformXXXType to build a new type. Subclasses
325	/// may override this function (to take over all type
326	/// transformations) or some set of the TransformXXXType functions
327	/// to alter the transformation.
328	TypeSourceInfo TransformType(TypeSourceInfo DI);
329
330	/// Transform the given type-with-location into a new
331	/// type, collecting location information in the given builder
332	/// as necessary.
333	///
334	QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
335
336	/// Transform a type that is permitted to produce a
337	/// DeducedTemplateSpecializationType.
338	///
339	/// This is used in the (relatively rare) contexts where it is acceptable
340	/// for transformation to produce a class template type with deduced
341	/// template arguments.
342	/// @{
343	QualType TransformTypeWithDeducedTST(QualType T);
344	TypeSourceInfo TransformTypeWithDeducedTST(TypeSourceInfo DI);
345	/// @}
346
347	/// The reason why the value of a statement is not discarded, if any.
348	enum StmtDiscardKind {
349	SDK_Discarded,
350	SDK_NotDiscarded,
351	SDK_StmtExprResult,
352	};
353
354	/// Transform the given statement.
355	///
356	/// By default, this routine transforms a statement by delegating to the
357	/// appropriate TransformXXXStmt function to transform a specific kind of
358	/// statement or the TransformExpr() function to transform an expression.
359	/// Subclasses may override this function to transform statements using some
360	/// other mechanism.
361	///
362	/// \returns the transformed statement.
363	StmtResult TransformStmt(Stmt *S, StmtDiscardKind SDK = SDK_Discarded);
364
365	/// Transform the given statement.
366	///
367	/// By default, this routine transforms a statement by delegating to the
368	/// appropriate TransformOMPXXXClause function to transform a specific kind
369	/// of clause. Subclasses may override this function to transform statements
370	/// using some other mechanism.
371	///
372	/// \returns the transformed OpenMP clause.
373	OMPClause TransformOMPClause(OMPClause S);
374
375	/// Transform the given attribute.
376	///
377	/// By default, this routine transforms a statement by delegating to the
378	/// appropriate TransformXXXAttr function to transform a specific kind
379	/// of attribute. Subclasses may override this function to transform
380	/// attributed statements using some other mechanism.
381	///
382	/// \returns the transformed attribute
383	const Attr TransformAttr(const Attr S);
384
385	/// Transform the specified attribute.
386	///
387	/// Subclasses should override the transformation of attributes with a pragma
388	/// spelling to transform expressions stored within the attribute.
389	///
390	/// \returns the transformed attribute.
391	#define ATTR(X)
392	#define PRAGMA_SPELLING_ATTR(X) \
393	const X##Attr Transform##X##Attr(const X##Attr R) { return R; }
394	#include "clang/Basic/AttrList.inc"
395
396	/// Transform the given expression.
397	///
398	/// By default, this routine transforms an expression by delegating to the
399	/// appropriate TransformXXXExpr function to build a new expression.
400	/// Subclasses may override this function to transform expressions using some
401	/// other mechanism.
402	///
403	/// \returns the transformed expression.
404	ExprResult TransformExpr(Expr *E);
405
406	/// Transform the given initializer.
407	///
408	/// By default, this routine transforms an initializer by stripping off the
409	/// semantic nodes added by initialization, then passing the result to
410	/// TransformExpr or TransformExprs.
411	///
412	/// \returns the transformed initializer.
413	ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);
414
415	/// Transform the given list of expressions.
416	///
417	/// This routine transforms a list of expressions by invoking
418	/// \c TransformExpr() for each subexpression. However, it also provides
419	/// support for variadic templates by expanding any pack expansions (if the
420	/// derived class permits such expansion) along the way. When pack expansions
421	/// are present, the number of outputs may not equal the number of inputs.
422	///
423	/// \param Inputs The set of expressions to be transformed.
424	///
425	/// \param NumInputs The number of expressions in \c Inputs.
426	///
427	/// \param IsCall If \c true, then this transform is being performed on
428	/// function-call arguments, and any arguments that should be dropped, will
429	/// be.
430	///
431	/// \param Outputs The transformed input expressions will be added to this
432	/// vector.
433	///
434	/// \param ArgChanged If non-NULL, will be set \c true if any argument changed
435	/// due to transformation.
436	///
437	/// \returns true if an error occurred, false otherwise.
438	bool TransformExprs(Expr const Inputs, unsigned NumInputs, bool IsCall,
439	SmallVectorImpl<Expr *> &Outputs,
440	bool *ArgChanged = nullptr);
441
442	/// Transform the given declaration, which is referenced from a type
443	/// or expression.
444	///
445	/// By default, acts as the identity function on declarations, unless the
446	/// transformer has had to transform the declaration itself. Subclasses
447	/// may override this function to provide alternate behavior.
448	Decl TransformDecl(SourceLocation Loc, Decl D) {
449	llvm::DenseMap<Decl , Decl >::iterator Known
450	= TransformedLocalDecls.find(D);
451	if (Known != TransformedLocalDecls.end())
452	return Known->second;
453
454	return D;
455	}
456
457	/// Transform the specified condition.
458	///
459	/// By default, this transforms the variable and expression and rebuilds
460	/// the condition.
461	Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
462	Expr *Expr,
463	Sema::ConditionKind Kind);
464
465	/// Transform the attributes associated with the given declaration and
466	/// place them on the new declaration.
467	///
468	/// By default, this operation does nothing. Subclasses may override this
469	/// behavior to transform attributes.
470	void transformAttrs(Decl Old, Decl New) { }
471
472	/// Note that a local declaration has been transformed by this
473	/// transformer.
474	///
475	/// Local declarations are typically transformed via a call to
476	/// TransformDefinition. However, in some cases (e.g., lambda expressions),
477	/// the transformer itself has to transform the declarations. This routine
478	/// can be overridden by a subclass that keeps track of such mappings.
479	void transformedLocalDecl(Decl Old, ArrayRef<Decl > New) {
480	assert(New.size() == 1 &&((New.size() == 1 && "must override transformedLocalDecl if performing pack expansion" ) ? static_cast<void> (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\"" , "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/TreeTransform.h" , 481, __PRETTY_FUNCTION__))
481	"must override transformedLocalDecl if performing pack expansion")((New.size() == 1 && "must override transformedLocalDecl if performing pack expansion" ) ? static_cast<void> (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\"" , "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/TreeTransform.h" , 481, __PRETTY_FUNCTION__));
482	TransformedLocalDecls[Old] = New.front();
483	}
484
485	/// Transform the definition of the given declaration.
486	///
487	/// By default, invokes TransformDecl() to transform the declaration.
488	/// Subclasses may override this function to provide alternate behavior.
489	Decl TransformDefinition(SourceLocation Loc, Decl D) {
490	return getDerived().TransformDecl(Loc, D);
491	}
492
493	/// Transform the given declaration, which was the first part of a
494	/// nested-name-specifier in a member access expression.
495	///
496	/// This specific declaration transformation only applies to the first
497	/// identifier in a nested-name-specifier of a member access expression, e.g.,
498	/// the \c T in \c x->T::member
499	///
500	/// By default, invokes TransformDecl() to transform the declaration.
501	/// Subclasses may override this function to provide alternate behavior.
502	NamedDecl TransformFirstQualifierInScope(NamedDecl D, SourceLocation Loc) {
503	return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
504	}
505
506	/// Transform the set of declarations in an OverloadExpr.
507	bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
508	LookupResult &R);
509
510	/// Transform the given nested-name-specifier with source-location
511	/// information.
512	///
513	/// By default, transforms all of the types and declarations within the
514	/// nested-name-specifier. Subclasses may override this function to provide
515	/// alternate behavior.
516	NestedNameSpecifierLoc
517	TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
518	QualType ObjectType = QualType(),
519	NamedDecl *FirstQualifierInScope = nullptr);
520
521	/// Transform the given declaration name.
522	///
523	/// By default, transforms the types of conversion function, constructor,
524	/// and destructor names and then (if needed) rebuilds the declaration name.
525	/// Identifiers and selectors are returned unmodified. Sublcasses may
526	/// override this function to provide alternate behavior.
527	DeclarationNameInfo
528	TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
529
530	bool TransformRequiresExprRequirements(ArrayRef<concepts::Requirement *> Reqs,
531	llvm::SmallVectorImpl<concepts::Requirement *> &Transformed);
532	concepts::TypeRequirement *
533	TransformTypeRequirement(concepts::TypeRequirement *Req);
534	concepts::ExprRequirement *
535	TransformExprRequirement(concepts::ExprRequirement *Req);
536	concepts::NestedRequirement *
537	TransformNestedRequirement(concepts::NestedRequirement *Req);
538
539	/// Transform the given template name.
540	///
541	/// \param SS The nested-name-specifier that qualifies the template
542	/// name. This nested-name-specifier must already have been transformed.
543	///
544	/// \param Name The template name to transform.
545	///
546	/// \param NameLoc The source location of the template name.
547	///
548	/// \param ObjectType If we're translating a template name within a member
549	/// access expression, this is the type of the object whose member template
550	/// is being referenced.
551	///
552	/// \param FirstQualifierInScope If the first part of a nested-name-specifier
553	/// also refers to a name within the current (lexical) scope, this is the
554	/// declaration it refers to.
555	///
556	/// By default, transforms the template name by transforming the declarations
557	/// and nested-name-specifiers that occur within the template name.
558	/// Subclasses may override this function to provide alternate behavior.
559	TemplateName
560	TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
561	SourceLocation NameLoc,
562	QualType ObjectType = QualType(),
563	NamedDecl *FirstQualifierInScope = nullptr,
564	bool AllowInjectedClassName = false);
565
566	/// Transform the given template argument.
567	///
568	/// By default, this operation transforms the type, expression, or
569	/// declaration stored within the template argument and constructs a
570	/// new template argument from the transformed result. Subclasses may
571	/// override this function to provide alternate behavior.
572	///
573	/// Returns true if there was an error.
574	bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
575	TemplateArgumentLoc &Output,
576	bool Uneval = false);
577
578	/// Transform the given set of template arguments.
579	///
580	/// By default, this operation transforms all of the template arguments
581	/// in the input set using \c TransformTemplateArgument(), and appends
582	/// the transformed arguments to the output list.
583	///
584	/// Note that this overload of \c TransformTemplateArguments() is merely
585	/// a convenience function. Subclasses that wish to override this behavior
586	/// should override the iterator-based member template version.
587	///
588	/// \param Inputs The set of template arguments to be transformed.
589	///
590	/// \param NumInputs The number of template arguments in \p Inputs.
591	///
592	/// \param Outputs The set of transformed template arguments output by this
593	/// routine.
594	///
595	/// Returns true if an error occurred.
596	bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
597	unsigned NumInputs,
598	TemplateArgumentListInfo &Outputs,
599	bool Uneval = false) {
600	return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
601	Uneval);
602	}
603
604	/// Transform the given set of template arguments.
605	///
606	/// By default, this operation transforms all of the template arguments
607	/// in the input set using \c TransformTemplateArgument(), and appends
608	/// the transformed arguments to the output list.
609	///
610	/// \param First An iterator to the first template argument.
611	///
612	/// \param Last An iterator one step past the last template argument.
613	///
614	/// \param Outputs The set of transformed template arguments output by this
615	/// routine.
616	///
617	/// Returns true if an error occurred.
618	template<typename InputIterator>
619	bool TransformTemplateArguments(InputIterator First,
620	InputIterator Last,
621	TemplateArgumentListInfo &Outputs,
622	bool Uneval = false);
623
624	/// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
625	void InventTemplateArgumentLoc(const TemplateArgument &Arg,
626	TemplateArgumentLoc &ArgLoc);
627
628	/// Fakes up a TypeSourceInfo for a type.
629	TypeSourceInfo *InventTypeSourceInfo(QualType T) {
630	return SemaRef.Context.getTrivialTypeSourceInfo(T,
631	getDerived().getBaseLocation());
632	}
633
634	#define ABSTRACT_TYPELOC(CLASS, PARENT)
635	#define TYPELOC(CLASS, PARENT) \
636	QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
637	#include "clang/AST/TypeLocNodes.def"
638
639	template<typename Fn>
640	QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
641	FunctionProtoTypeLoc TL,
642	CXXRecordDecl *ThisContext,
643	Qualifiers ThisTypeQuals,
644	Fn TransformExceptionSpec);
645
646	bool TransformExceptionSpec(SourceLocation Loc,
647	FunctionProtoType::ExceptionSpecInfo &ESI,
648	SmallVectorImpl<QualType> &Exceptions,
649	bool &Changed);
650
651	StmtResult TransformSEHHandler(Stmt *Handler);
652
653	QualType
654	TransformTemplateSpecializationType(TypeLocBuilder &TLB,
655	TemplateSpecializationTypeLoc TL,
656	TemplateName Template);
657
658	QualType
659	TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
660	DependentTemplateSpecializationTypeLoc TL,
661	TemplateName Template,
662	CXXScopeSpec &SS);
663
664	QualType TransformDependentTemplateSpecializationType(
665	TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
666	NestedNameSpecifierLoc QualifierLoc);
667
668	/// Transforms the parameters of a function type into the
669	/// given vectors.
670	///
671	/// The result vectors should be kept in sync; null entries in the
672	/// variables vector are acceptable.
673	///
674	/// Return true on error.
675	bool TransformFunctionTypeParams(
676	SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
677	const QualType *ParamTypes,
678	const FunctionProtoType::ExtParameterInfo *ParamInfos,
679	SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl > PVars,
680	Sema::ExtParameterInfoBuilder &PInfos);
681
682	/// Transforms a single function-type parameter. Return null
683	/// on error.
684	///
685	/// \param indexAdjustment - A number to add to the parameter's
686	/// scope index; can be negative
687	ParmVarDecl TransformFunctionTypeParam(ParmVarDecl OldParm,
688	int indexAdjustment,
689	Optional<unsigned> NumExpansions,
690	bool ExpectParameterPack);
691
692	/// Transform the body of a lambda-expression.
693	StmtResult TransformLambdaBody(LambdaExpr E, Stmt Body);
694	/// Alternative implementation of TransformLambdaBody that skips transforming
695	/// the body.
696	StmtResult SkipLambdaBody(LambdaExpr E, Stmt Body);
697
698	QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
699
700	StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
701	ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
702
703	TemplateParameterList *TransformTemplateParameterList(
704	TemplateParameterList *TPL) {
705	return TPL;
706	}
707
708	ExprResult TransformAddressOfOperand(Expr *E);
709
710	ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
711	bool IsAddressOfOperand,
712	TypeSourceInfo **RecoveryTSI);
713
714	ExprResult TransformParenDependentScopeDeclRefExpr(
715	ParenExpr PE, DependentScopeDeclRefExpr DRE, bool IsAddressOfOperand,
716	TypeSourceInfo **RecoveryTSI);
717
718	StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
719
720	// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
721	// amount of stack usage with clang.
722	#define STMT(Node, Parent) \
723	LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
724	StmtResult Transform##Node(Node *S);
725	#define VALUESTMT(Node, Parent) \
726	LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
727	StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
728	#define EXPR(Node, Parent) \
729	LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
730	ExprResult Transform##Node(Node *E);
731	#define ABSTRACT_STMT(Stmt)
732	#include "clang/AST/StmtNodes.inc"
733
734	#define GEN_CLANG_CLAUSE_CLASS
735	#define CLAUSE_CLASS(Enum, Str, Class) \
736	LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
737	OMPClause Transform##Class(Class S);
738	#include "llvm/Frontend/OpenMP/OMP.inc"
739
740	/// Build a new qualified type given its unqualified type and type location.
741	///
742	/// By default, this routine adds type qualifiers only to types that can
743	/// have qualifiers, and silently suppresses those qualifiers that are not
744	/// permitted. Subclasses may override this routine to provide different
745	/// behavior.
746	QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);
747
748	/// Build a new pointer type given its pointee type.
749	///
750	/// By default, performs semantic analysis when building the pointer type.
751	/// Subclasses may override this routine to provide different behavior.
752	QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
753
754	/// Build a new block pointer type given its pointee type.
755	///
756	/// By default, performs semantic analysis when building the block pointer
757	/// type. Subclasses may override this routine to provide different behavior.
758	QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
759
760	/// Build a new reference type given the type it references.
761	///
762	/// By default, performs semantic analysis when building the
763	/// reference type. Subclasses may override this routine to provide
764	/// different behavior.
765	///
766	/// \param LValue whether the type was written with an lvalue sigil
767	/// or an rvalue sigil.
768	QualType RebuildReferenceType(QualType ReferentType,
769	bool LValue,
770	SourceLocation Sigil);
771
772	/// Build a new member pointer type given the pointee type and the
773	/// class type it refers into.
774	///
775	/// By default, performs semantic analysis when building the member pointer
776	/// type. Subclasses may override this routine to provide different behavior.
777	QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
778	SourceLocation Sigil);
779
780	QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
781	SourceLocation ProtocolLAngleLoc,
782	ArrayRef<ObjCProtocolDecl *> Protocols,
783	ArrayRef<SourceLocation> ProtocolLocs,
784	SourceLocation ProtocolRAngleLoc);
785
786	/// Build an Objective-C object type.
787	///
788	/// By default, performs semantic analysis when building the object type.
789	/// Subclasses may override this routine to provide different behavior.
790	QualType RebuildObjCObjectType(QualType BaseType,
791	SourceLocation Loc,
792	SourceLocation TypeArgsLAngleLoc,
793	ArrayRef<TypeSourceInfo *> TypeArgs,
794	SourceLocation TypeArgsRAngleLoc,
795	SourceLocation ProtocolLAngleLoc,
796	ArrayRef<ObjCProtocolDecl *> Protocols,
797	ArrayRef<SourceLocation> ProtocolLocs,
798	SourceLocation ProtocolRAngleLoc);
799
800	/// Build a new Objective-C object pointer type given the pointee type.
801	///
802	/// By default, directly builds the pointer type, with no additional semantic
803	/// analysis.
804	QualType RebuildObjCObjectPointerType(QualType PointeeType,
805	SourceLocation Star);
806
807	/// Build a new array type given the element type, size
808	/// modifier, size of the array (if known), size expression, and index type
809	/// qualifiers.
810	///
811	/// By default, performs semantic analysis when building the array type.
812	/// Subclasses may override this routine to provide different behavior.
813	/// Also by default, all of the other Rebuild*Array
814	QualType RebuildArrayType(QualType ElementType,
815	ArrayType::ArraySizeModifier SizeMod,
816	const llvm::APInt *Size,
817	Expr *SizeExpr,
818	unsigned IndexTypeQuals,
819	SourceRange BracketsRange);
820
821	/// Build a new constant array type given the element type, size
822	/// modifier, (known) size of the array, and index type qualifiers.
823	///
824	/// By default, performs semantic analysis when building the array type.
825	/// Subclasses may override this routine to provide different behavior.
826	QualType RebuildConstantArrayType(QualType ElementType,
827	ArrayType::ArraySizeModifier SizeMod,
828	const llvm::APInt &Size,
829	Expr *SizeExpr,
830	unsigned IndexTypeQuals,
831	SourceRange BracketsRange);
832
833	/// Build a new incomplete array type given the element type, size
834	/// modifier, and index type qualifiers.
835	///
836	/// By default, performs semantic analysis when building the array type.
837	/// Subclasses may override this routine to provide different behavior.
838	QualType RebuildIncompleteArrayType(QualType ElementType,
839	ArrayType::ArraySizeModifier SizeMod,
840	unsigned IndexTypeQuals,
841	SourceRange BracketsRange);
842
843	/// Build a new variable-length array type given the element type,
844	/// size modifier, size expression, and index type qualifiers.
845	///
846	/// By default, performs semantic analysis when building the array type.
847	/// Subclasses may override this routine to provide different behavior.
848	QualType RebuildVariableArrayType(QualType ElementType,
849	ArrayType::ArraySizeModifier SizeMod,
850	Expr *SizeExpr,
851	unsigned IndexTypeQuals,
852	SourceRange BracketsRange);
853
854	/// Build a new dependent-sized array type given the element type,
855	/// size modifier, size expression, and index type qualifiers.
856	///
857	/// By default, performs semantic analysis when building the array type.
858	/// Subclasses may override this routine to provide different behavior.
859	QualType RebuildDependentSizedArrayType(QualType ElementType,
860	ArrayType::ArraySizeModifier SizeMod,
861	Expr *SizeExpr,
862	unsigned IndexTypeQuals,
863	SourceRange BracketsRange);
864
865	/// Build a new vector type given the element type and
866	/// number of elements.
867	///
868	/// By default, performs semantic analysis when building the vector type.
869	/// Subclasses may override this routine to provide different behavior.
870	QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
871	VectorType::VectorKind VecKind);
872
873	/// Build a new potentially dependently-sized extended vector type
874	/// given the element type and number of elements.
875	///
876	/// By default, performs semantic analysis when building the vector type.
877	/// Subclasses may override this routine to provide different behavior.
878	QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
879	SourceLocation AttributeLoc,
880	VectorType::VectorKind);
881
882	/// Build a new extended vector type given the element type and
883	/// number of elements.
884	///
885	/// By default, performs semantic analysis when building the vector type.
886	/// Subclasses may override this routine to provide different behavior.
887	QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
888	SourceLocation AttributeLoc);
889
890	/// Build a new potentially dependently-sized extended vector type
891	/// given the element type and number of elements.
892	///
893	/// By default, performs semantic analysis when building the vector type.
894	/// Subclasses may override this routine to provide different behavior.
895	QualType RebuildDependentSizedExtVectorType(QualType ElementType,
896	Expr *SizeExpr,
897	SourceLocation AttributeLoc);
898
899	/// Build a new matrix type given the element type and dimensions.
900	QualType RebuildConstantMatrixType(QualType ElementType, unsigned NumRows,
901	unsigned NumColumns);
902
903	/// Build a new matrix type given the type and dependently-defined
904	/// dimensions.
905	QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
906	Expr *ColumnExpr,
907	SourceLocation AttributeLoc);
908
909	/// Build a new DependentAddressSpaceType or return the pointee
910	/// type variable with the correct address space (retrieved from
911	/// AddrSpaceExpr) applied to it. The former will be returned in cases
912	/// where the address space remains dependent.
913	///
914	/// By default, performs semantic analysis when building the type with address
915	/// space applied. Subclasses may override this routine to provide different
916	/// behavior.
917	QualType RebuildDependentAddressSpaceType(QualType PointeeType,
918	Expr *AddrSpaceExpr,
919	SourceLocation AttributeLoc);
920
921	/// Build a new function type.
922	///
923	/// By default, performs semantic analysis when building the function type.
924	/// Subclasses may override this routine to provide different behavior.
925	QualType RebuildFunctionProtoType(QualType T,
926	MutableArrayRef<QualType> ParamTypes,
927	const FunctionProtoType::ExtProtoInfo &EPI);
928
929	/// Build a new unprototyped function type.
930	QualType RebuildFunctionNoProtoType(QualType ResultType);
931
932	/// Rebuild an unresolved typename type, given the decl that
933	/// the UnresolvedUsingTypenameDecl was transformed to.
934	QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
935
936	/// Build a new typedef type.
937	QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
938	return SemaRef.Context.getTypeDeclType(Typedef);
939	}
940
941	/// Build a new MacroDefined type.
942	QualType RebuildMacroQualifiedType(QualType T,
943	const IdentifierInfo *MacroII) {
944	return SemaRef.Context.getMacroQualifiedType(T, MacroII);
945	}
946
947	/// Build a new class/struct/union type.
948	QualType RebuildRecordType(RecordDecl *Record) {
949	return SemaRef.Context.getTypeDeclType(Record);
950	}
951
952	/// Build a new Enum type.
953	QualType RebuildEnumType(EnumDecl *Enum) {
954	return SemaRef.Context.getTypeDeclType(Enum);
955	}
956
957	/// Build a new typeof(expr) type.
958	///
959	/// By default, performs semantic analysis when building the typeof type.
960	/// Subclasses may override this routine to provide different behavior.
961	QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
962
963	/// Build a new typeof(type) type.
964	///
965	/// By default, builds a new TypeOfType with the given underlying type.
966	QualType RebuildTypeOfType(QualType Underlying);
967
968	/// Build a new unary transform type.
969	QualType RebuildUnaryTransformType(QualType BaseType,
970	UnaryTransformType::UTTKind UKind,
971	SourceLocation Loc);
972
973	/// Build a new C++11 decltype type.
974	///
975	/// By default, performs semantic analysis when building the decltype type.
976	/// Subclasses may override this routine to provide different behavior.
977	QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
978
979	/// Build a new C++11 auto type.
980	///
981	/// By default, builds a new AutoType with the given deduced type.
982	QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword,
983	ConceptDecl *TypeConstraintConcept,
984	ArrayRef<TemplateArgument> TypeConstraintArgs) {
985	// Note, IsDependent is always false here: we implicitly convert an 'auto'
986	// which has been deduced to a dependent type into an undeduced 'auto', so
987	// that we'll retry deduction after the transformation.
988	return SemaRef.Context.getAutoType(Deduced, Keyword,
989	/IsDependent/ false, /IsPack=/false,
990	TypeConstraintConcept,
991	TypeConstraintArgs);
992	}
993
994	/// By default, builds a new DeducedTemplateSpecializationType with the given
995	/// deduced type.
996	QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
997	QualType Deduced) {
998	return SemaRef.Context.getDeducedTemplateSpecializationType(
999	Template, Deduced, /IsDependent/ false);
1000	}
1001
1002	/// Build a new template specialization type.
1003	///
1004	/// By default, performs semantic analysis when building the template
1005	/// specialization type. Subclasses may override this routine to provide
1006	/// different behavior.
1007	QualType RebuildTemplateSpecializationType(TemplateName Template,
1008	SourceLocation TemplateLoc,
1009	TemplateArgumentListInfo &Args);
1010
1011	/// Build a new parenthesized type.
1012	///
1013	/// By default, builds a new ParenType type from the inner type.
1014	/// Subclasses may override this routine to provide different behavior.
1015	QualType RebuildParenType(QualType InnerType) {
1016	return SemaRef.BuildParenType(InnerType);
1017	}
1018
1019	/// Build a new qualified name type.
1020	///
1021	/// By default, builds a new ElaboratedType type from the keyword,
1022	/// the nested-name-specifier and the named type.
1023	/// Subclasses may override this routine to provide different behavior.
1024	QualType RebuildElaboratedType(SourceLocation KeywordLoc,
1025	ElaboratedTypeKeyword Keyword,
1026	NestedNameSpecifierLoc QualifierLoc,
1027	QualType Named) {
1028	return SemaRef.Context.getElaboratedType(Keyword,
1029	QualifierLoc.getNestedNameSpecifier(),
1030	Named);
1031	}
1032
1033	/// Build a new typename type that refers to a template-id.
1034	///
1035	/// By default, builds a new DependentNameType type from the
1036	/// nested-name-specifier and the given type. Subclasses may override
1037	/// this routine to provide different behavior.
1038	QualType RebuildDependentTemplateSpecializationType(
1039	ElaboratedTypeKeyword Keyword,
1040	NestedNameSpecifierLoc QualifierLoc,
1041	SourceLocation TemplateKWLoc,
1042	const IdentifierInfo *Name,
1043	SourceLocation NameLoc,
1044	TemplateArgumentListInfo &Args,
1045	bool AllowInjectedClassName) {
1046	// Rebuild the template name.
1047	// TODO: avoid TemplateName abstraction
1048	CXXScopeSpec SS;
1049	SS.Adopt(QualifierLoc);
1050	TemplateName InstName = getDerived().RebuildTemplateName(
1051	SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
1052	AllowInjectedClassName);
1053
1054	if (InstName.isNull())
1055	return QualType();
1056
1057	// If it's still dependent, make a dependent specialization.
1058	if (InstName.getAsDependentTemplateName())
1059	return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
1060	QualifierLoc.getNestedNameSpecifier(),
1061	Name,
1062	Args);
1063
1064	// Otherwise, make an elaborated type wrapping a non-dependent
1065	// specialization.
1066	QualType T =
1067	getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1068	if (T.isNull()) return QualType();
1069
1070	if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
1071	return T;
1072
1073	return SemaRef.Context.getElaboratedType(Keyword,
1074	QualifierLoc.getNestedNameSpecifier(),
1075	T);
1076	}
1077
1078	/// Build a new typename type that refers to an identifier.
1079	///
1080	/// By default, performs semantic analysis when building the typename type
1081	/// (or elaborated type). Subclasses may override this routine to provide
1082	/// different behavior.
1083	QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
1084	SourceLocation KeywordLoc,
1085	NestedNameSpecifierLoc QualifierLoc,
1086	const IdentifierInfo *Id,
1087	SourceLocation IdLoc,
1088	bool DeducedTSTContext) {
1089	CXXScopeSpec SS;
1090	SS.Adopt(QualifierLoc);
1091
1092	if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1093	// If the name is still dependent, just build a new dependent name type.
1094	if (!SemaRef.computeDeclContext(SS))
1095	return SemaRef.Context.getDependentNameType(Keyword,
1096	QualifierLoc.getNestedNameSpecifier(),
1097	Id);
1098	}
1099
1100	if (Keyword == ETK_None \|\| Keyword == ETK_Typename) {
1101	return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
1102	*Id, IdLoc, DeducedTSTContext);
1103	}
1104
1105	TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1106
1107	// We had a dependent elaborated-type-specifier that has been transformed
1108	// into a non-dependent elaborated-type-specifier. Find the tag we're
1109	// referring to.
1110	LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1111	DeclContext *DC = SemaRef.computeDeclContext(SS, false);
1112	if (!DC)
1113	return QualType();
1114
1115	if (SemaRef.RequireCompleteDeclContext(SS, DC))
1116	return QualType();
1117
1118	TagDecl *Tag = nullptr;
1119	SemaRef.LookupQualifiedName(Result, DC);
1120	switch (Result.getResultKind()) {
1121	case LookupResult::NotFound:
1122	case LookupResult::NotFoundInCurrentInstantiation:
1123	break;
1124
1125	case LookupResult::Found:
1126	Tag = Result.getAsSingle<TagDecl>();
1127	break;
1128
1129	case LookupResult::FoundOverloaded:
1130	case LookupResult::FoundUnresolvedValue:
1131	llvm_unreachable("Tag lookup cannot find non-tags")::llvm::llvm_unreachable_internal("Tag lookup cannot find non-tags" , "/build/llvm-toolchain-snapshot-12~++20210115100614+a14c36fe27f5/clang/lib/Sema/TreeTransform.h" , 1131);
1132
1133	case LookupResult::Ambiguous:
1134	// Let the LookupResult structure handle ambiguities.
1135	return QualType();
1136	}
1137
1138	if (!Tag) {
1139	// Check where the name exists but isn't a tag type and use that to emit
1140	// better diagnostics.
1141	LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1142	SemaRef.LookupQualifiedName(Result, DC);
1143	switch (Result.getResultKind()) {
1144	case LookupResult::Found:
1145	case LookupResult::FoundOverloaded:
1146	case LookupResult::FoundUnresolvedValue: {
1147	NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1148	Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
1149	SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1150	<< NTK << Kind;
1151	SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1152	break;
1153	}
1154	default:
1155	SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1156	<< Kind << Id << DC << QualifierLoc.getSourceRange();
1157	break;
1158	}
1159	return QualType();
1160	}
1161
1162	if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /isDefinition/false,
1163	IdLoc, Id)) {
1164	SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1165	SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1166	return QualType();
1167	}
1168
1169	// Build the elaborated-type-specifier type.
1170	QualType T = SemaRef.Context.getTypeDeclType(Tag);
1171	return SemaRef.Context.getElaboratedType(Keyword,
1172	QualifierLoc.getNestedNameSpecifier(),
1173	T);
1174	}
1175
1176	/// Build a new pack expansion type.
1177	///
1178	/// By default, builds a new PackExpansionType type from the given pattern.
1179	/// Subclasses may override this routine to provide different behavior.
1180	QualType RebuildPackExpansionType(QualType Pattern,
1181	SourceRange PatternRange,
1182	SourceLocation EllipsisLoc,
1183	Optional<unsigned> NumExpansions) {
1184	return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1185	NumExpansions);
1186	}
1187
1188	/// Build a new atomic type given its value type.
1189	///
1190	/// By default, performs semantic analysis when building the atomic type.
1191	/// Subclasses may override this routine to provide different behavior.
1192	QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1193
1194	/// Build a new pipe type given its value type.
1195	QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
1196	bool isReadPipe);
1197
1198	/// Build an extended int given its value type.
1199	QualType RebuildExtIntType(bool IsUnsigned, unsigned NumBits,
1200	SourceLocation Loc);
1201
1202	/// Build a dependent extended int given its value type.
1203	QualType RebuildDependentExtIntType(bool IsUnsigned, Expr *NumBitsExpr,
1204	SourceLocation Loc);
1205
1206	/// Build a new template name given a nested name specifier, a flag
1207	/// indicating whether the "template" keyword was provided, and the template
1208	/// that the template name refers to.
1209	///
1210	/// By default, builds the new template name directly. Subclasses may override
1211	/// this routine to provide different behavior.
1212	TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1213	bool TemplateKW,
1214	TemplateDecl *Template);
1215
1216	/// Build a new template name given a nested name specifier and the
1217	/// name that is referred to as a template.
1218	///
1219	/// By default, performs semantic analysis to determine whether the name can
1220	/// be resolved to a specific template, then builds the appropriate kind of
1221	/// template name. Subclasses may override this routine to provide different
1222	/// behavior.
1223	TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1224	SourceLocation TemplateKWLoc,
1225	const IdentifierInfo &Name,
1226	SourceLocation NameLoc, QualType ObjectType,
1227	NamedDecl *FirstQualifierInScope,
1228	bool AllowInjectedClassName);
1229
1230	/// Build a new template name given a nested name specifier and the
1231	/// overloaded operator name that is referred to as a template.
1232	///
1233	/// By default, performs semantic analysis to determine whether the name can
1234	/// be resolved to a specific template, then builds the appropriate kind of
1235	/// template name. Subclasses may override this routine to provide different
1236	/// behavior.
1237	TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1238	SourceLocation TemplateKWLoc,
1239	OverloadedOperatorKind Operator,
1240	SourceLocation NameLoc, QualType ObjectType,
1241	bool AllowInjectedClassName);
1242
1243	/// Build a new template name given a template template parameter pack
1244	/// and the
1245	///
1246	/// By default, performs semantic analysis to determine whether the name can
1247	/// be resolved to a specific template, then builds the appropriate kind of
1248	/// template name. Subclasses may override this routine to provide different
1249	/// behavior.
1250	TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
1251	const TemplateArgument &ArgPack) {
1252	return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1253	}
1254
1255	/// Build a new compound statement.
1256	///
1257	/// By default, performs semantic analysis to build the new statement.
1258	/// Subclasses may override this routine to provide different behavior.
1259	StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1260	MultiStmtArg Statements,
1261	SourceLocation RBraceLoc,
1262	bool IsStmtExpr) {
1263	return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1264	IsStmtExpr);
1265	}
1266
1267	/// Build a new case statement.
1268	///
1269	/// By default, performs semantic analysis to build the new statement.
1270	/// Subclasses may override this routine to provide different behavior.
1271	StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1272	Expr *LHS,
1273	SourceLocation EllipsisLoc,
1274	Expr *RHS,
1275	SourceLocation ColonLoc) {
1276	return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1277	ColonLoc);
1278	}
1279
1280	/// Attach the body to a new case statement.
1281	///
1282	/// By default, performs semantic analysis to build the new statement.
1283	/// Subclasses may override this routine to provide different behavior.
1284	StmtResult RebuildCaseStmtBody(Stmt S, Stmt Body) {
1285	getSema().ActOnCaseStmtBody(S, Body);
1286	return S;
1287	}
1288
1289	/// Build a new default statement.
1290	///
1291	/// By default, performs semantic analysis to build the new statement.
1292	/// Subclasses may override this routine to provide different behavior.
1293	StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1294	SourceLocation ColonLoc,
1295	Stmt *SubStmt) {
1296	return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1297	/CurScope=/nullptr);
1298	}
1299
1300	/// Build a new label statement.
1301	///
1302	/// By default, performs semantic analysis to build the new statement.
1303	/// Subclasses may override this routine to provide different behavior.
1304	StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1305	SourceLocation ColonLoc, Stmt *SubStmt) {
1306	return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1307	}
1308
1309	/// Build a new attributed statement.
1310	///
1311	/// By default, performs semantic analysis to build the new statement.
1312	/// Subclasses may override this routine to provide different behavior.
1313	StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1314	ArrayRef<const Attr*> Attrs,
1315	Stmt *SubStmt) {
1316	return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1317	}
1318
1319	/// Build a new "if" statement.
1320	///
1321	/// By default, performs semantic analysis to build the new statement.
1322	/// Subclasses may override this routine to provide different behavior.
1323	StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
1324	SourceLocation LParenLoc, Sema::ConditionResult Cond,
1325	SourceLocation RParenLoc, Stmt Init, Stmt Then,
1326	SourceLocation ElseLoc, Stmt *Else) {
1327	return getSema().ActOnIfStmt(IfLoc, IsConstexpr, LParenLoc, Init, Cond,
1328	RParenLoc, Then, ElseLoc, Else);
1329	}
1330
1331	/// Start building a new switch statement.
1332	///
1333	/// By default, performs semantic analysis to build the new statement.
1334	/// Subclasses may override this routine to provide different behavior.
1335	StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
1336	SourceLocation LParenLoc, Stmt *Init,
1337	Sema::ConditionResult Cond,
1338	SourceLocation RParenLoc) {
1339	return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond,
1340	RParenLoc);
1341	}
1342
1343	/// Attach the body to the switch statement.
1344	///
1345	/// By default, performs semantic analysis to build the new statement.
1346	/// Subclasses may override this routine to provide different behavior.
1347	StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1348	Stmt Switch, Stmt Body) {
1349	return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1350	}
1351
1352	/// Build a new while statement.
1353	///
1354	/// By default, performs semantic analysis to build the new statement.
1355	/// Subclasses may override this routine to provide different behavior.
1356	StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
1357	Sema::ConditionResult Cond,
1358	SourceLocation RParenLoc, Stmt *Body) {
1359	return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body);
1360	}
1361
1362	/// Build a new do-while statement.
1363	///
1364	/// By default, performs semantic analysis to build the new statement.
1365	/// Subclasses may override this routine to provide different behavior.
1366	StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1367	SourceLocation WhileLoc, SourceLocation LParenLoc,
1368	Expr *Cond, SourceLocation RParenLoc) {
1369	return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1370	Cond, RParenLoc);
1371	}
1372
1373	/// Build a new for statement.
1374	///
1375	/// By default, performs semantic analysis to build the new statement.
1376	/// Subclasses may override this routine to provide different behavior.
1377	StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1378	Stmt *Init, Sema::ConditionResult Cond,
1379	Sema::FullExprArg Inc, SourceLocation RParenLoc,
1380	Stmt *Body) {
1381	return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1382	Inc, RParenLoc, Body);
1383	}
1384
1385	/// Build a new goto statement.
1386	///
1387	/// By default, performs semantic analysis to build the new statement.
1388	/// Subclasses may override this routine to provide different behavior.
1389	StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1390	LabelDecl *Label) {
1391	return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1392	}
1393
1394	/// Build a new indirect goto statement.
1395	///
1396	/// By default, performs semantic analysis to build the new statement.
1397	/// Subclasses may override this routine to provide different behavior.
1398	StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1399	SourceLocation StarLoc,
1400	Expr *Target) {
1401	return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1402	}
1403
1404	/// Build a new return statement.
1405	///
1406	/// By default, performs semantic analysis to build the new statement.
1407	/// Subclasses may override this routine to provide different behavior.
1408	StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1409	return getSema().BuildReturnStmt(ReturnLoc, Result);
1410	}
1411
1412	/// Build a new declaration statement.
1413	///
1414	/// By default, performs semantic analysis to build the new statement.
1415	/// Subclasses may override this routine to provide different behavior.
1416	StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1417	SourceLocation StartLoc, SourceLocation EndLoc) {
1418	Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1419	return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1420	}
1421
1422	/// Build a new inline asm statement.
1423	///
1424	/// By default, performs semantic analysis to build the new statement.
1425	/// Subclasses may override this routine to provide different behavior.
1426	StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1427	bool IsVolatile, unsigned NumOutputs,
1428	unsigned NumInputs, IdentifierInfo **Names,
1429	MultiExprArg Constraints, MultiExprArg Exprs,
1430	Expr *AsmString, MultiExprArg Clobbers,
1431	unsigned NumLabels,
1432	SourceLocation RParenLoc) {
1433	return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1434	NumInputs, Names, Constraints, Exprs,
1435	AsmString, Clobbers, NumLabels, RParenLoc);
1436	}
1437
1438	/// Build a new MS style inline asm statement.
1439	///
1440	/// By default, performs semantic analysis to build the new statement.
1441	/// Subclasses may override this routine to provide different behavior.
1442	StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1443	ArrayRef<Token> AsmToks,
1444	StringRef AsmString,
1445	unsigned NumOutputs, unsigned NumInputs,
1446	ArrayRef<StringRef> Constraints,
1447	ArrayRef<StringRef> Clobbers,
1448	ArrayRef<Expr*> Exprs,
1449	SourceLocation EndLoc) {
1450	return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1451	NumOutputs, NumInputs,
1452	Constraints, Clobbers, Exprs, EndLoc);
1453	}
1454
1455	/// Build a new co_return statement.
1456	///
1457	/// By default, performs semantic analysis to build the new statement.
1458	/// Subclasses may override this routine to provide different behavior.
1459	StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
1460	bool IsImplicit) {
1461	return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1462	}
1463
1464	/// Build a new co_await expression.
1465	///
1466	/// By default, performs semantic analysis to build the new expression.
1467	/// Subclasses may override this routine to provide different behavior.
1468	ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result,
1469	bool IsImplicit) {
1470	return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit);
1471	}
1472
1473	/// Build a new co_await expression.
1474	///
1475	/// By default, performs semantic analysis to build the new expression.
1476	/// Subclasses may override this routine to provide different behavior.
1477	ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
1478	Expr *Result,
1479	UnresolvedLookupExpr *Lookup) {
1480	return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1481	}
1482
1483	/// Build a new co_yield expression.
1484	///
1485	/// By default, performs semantic analysis to build the new expression.
1486	/// Subclasses may override this routine to provide different behavior.
1487	ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1488	return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1489	}
1490
1491	StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
1492	return getSema().BuildCoroutineBodyStmt(Args);
1493	}
1494
1495	/// Build a new Objective-C \@try statement.
1496	///
1497	/// By default, performs semantic analysis to build the new statement.
1498	/// Subclasses may override this routine to provide different behavior.
1499	StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1500	Stmt *TryBody,
1501	MultiStmtArg CatchStmts,
1502	Stmt *Finally) {
1503	return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1504	Finally);
1505	}
1506
1507	/// Rebuild an Objective-C exception declaration.
1508	///
1509	/// By default, performs semantic analysis to build the new declaration.
1510	/// Subclasses may override this routine to provide different behavior.
1511	VarDecl RebuildObjCExceptionDecl(VarDecl ExceptionDecl,
1512	TypeSourceInfo *TInfo, QualType T) {
1513	return getSema().BuildObjCExceptionDecl(TInfo, T,
1514	ExceptionDecl->getInnerLocStart(),
1515	ExceptionDecl->getLocation(),
1516	ExceptionDecl->getIdentifier());
1517	}
1518
1519	/// Build a new Objective-C \@catch statement.
1520	///
1521	/// By default, performs semantic analysis to build the new statement.
1522	/// Subclasses may override this routine to provide different behavior.
1523	StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1524	SourceLocation RParenLoc,
1525	VarDecl *Var,
1526	Stmt *Body) {
1527	return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1528	Var, Body);
1529	}
1530
1531	/// Build a new Objective-C \@finally statement.
1532	///
1533	/// By default, performs semantic analysis to build the new statement.
1534	/// Subclasses may override this routine to provide different behavior.
1535	StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1536	Stmt *Body) {
1537	return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1538	}
1539
1540	/// Build a new Objective-C \@throw statement.
1541	///
1542	/// By default, performs semantic analysis to build the new statement.
1543	/// Subclasses may override this routine to provide different behavior.
1544	StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1545	Expr *Operand) {
1546	return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1547	}
1548
1549	/// Build a new OpenMP executable directive.
1550	///
1551	/// By default, performs semantic analysis to build the new statement.
1552	/// Subclasses may override this routine to provide different behavior.
1553	StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1554	DeclarationNameInfo DirName,
1555	OpenMPDirectiveKind CancelRegion,
1556	ArrayRef<OMPClause *> Clauses,
1557	Stmt *AStmt, SourceLocation StartLoc,
1558	SourceLocation EndLoc) {
1559	return getSema().ActOnOpenMPExecutableDirective(
1560	Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1561	}
1562
1563	/// Build a new OpenMP 'if' clause.
1564	///
1565	/// By default, performs semantic analysis to build the new OpenMP clause.
1566	/// Subclasses may override this routine to provide different behavior.
1567	OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1568	Expr *Condition, SourceLocation StartLoc,
1569	SourceLocation LParenLoc,
1570	SourceLocation NameModifierLoc,
1571	SourceLocation ColonLoc,
1572	SourceLocation EndLoc) {
1573	return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1574	LParenLoc, NameModifierLoc, ColonLoc,
1575	EndLoc);
1576	}
1577
1578	/// Build a new OpenMP 'final' clause.
1579	///
1580	/// By default, performs semantic analysis to build the new OpenMP clause.
1581	/// Subclasses may override this routine to provide different behavior.
1582	OMPClause RebuildOMPFinalClause(Expr Condition, SourceLocation StartLoc,
1583	SourceLocation LParenLoc,
1584	SourceLocation EndLoc) {
1585	return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1586	EndLoc);
1587	}
1588
1589	/// Build a new OpenMP 'num_threads' clause.
1590	///
1591	/// By default, performs semantic analysis to build the new OpenMP clause.
1592	/// Subclasses may override this routine to provide different behavior.
1593	OMPClause RebuildOMPNumThreadsClause(Expr NumThreads,
1594	SourceLocation StartLoc,
1595	SourceLocation LParenLoc,
1596	SourceLocation EndLoc) {
1597	return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1598	LParenLoc, EndLoc);
1599	}
1600
1601	/// Build a new OpenMP 'safelen' clause.
1602	///
1603	/// By default, performs semantic analysis to build the new OpenMP clause.
1604	/// Subclasses may override this routine to provide different behavior.
1605	OMPClause RebuildOMPSafelenClause(Expr Len, SourceLocation StartLoc,
1606	SourceLocation LParenLoc,
1607	SourceLocation EndLoc) {
1608	return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1609	}
1610
1611	/// Build a new OpenMP 'simdlen' clause.
1612	///
1613	/// By default, performs semantic analysis to build the new OpenMP clause.
1614	/// Subclasses may override this routine to provide different behavior.
1615	OMPClause RebuildOMPSimdlenClause(Expr Len, SourceLocation StartLoc,
1616	SourceLocation LParenLoc,
1617	SourceLocation EndLoc) {
1618	return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1619	}
1620
1621	/// Build a new OpenMP 'allocator' clause.
1622	///
1623	/// By default, performs semantic analysis to build the new OpenMP clause.
1624	/// Subclasses may override this routine to provide different behavior.
1625	OMPClause RebuildOMPAllocatorClause(Expr A, SourceLocation StartLoc,
1626	SourceLocation LParenLoc,
1627	SourceLocation EndLoc) {
1628	return getSema().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, EndLoc);
1629	}
1630
1631	/// Build a new OpenMP 'collapse' clause.
1632	///
1633	/// By default, performs semantic analysis to build the new OpenMP clause.
1634	/// Subclasses may override this routine to provide different behavior.
1635	OMPClause RebuildOMPCollapseClause(Expr Num, SourceLocation StartLoc,
1636	SourceLocation LParenLoc,
1637	SourceLocation EndLoc) {
1638	return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1639	EndLoc);
1640	}
1641
1642	/// Build a new OpenMP 'default' clause.
1643	///
1644	/// By default, performs semantic analysis to build the new OpenMP clause.
1645	/// Subclasses may override this routine to provide different behavior.
1646	OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc,
1647	SourceLocation StartLoc,
1648	SourceLocation LParenLoc,
1649	SourceLocation EndLoc) {
1650	return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1651	StartLoc, LParenLoc, EndLoc);
1652	}
1653
1654	/// Build a new OpenMP 'proc_bind' clause.
1655	///
1656	/// By default, performs semantic analysis to build the new OpenMP clause.
1657	/// Subclasses may override this routine to provide different behavior.
1658	OMPClause *RebuildOMPProcBindClause(ProcBindKind Kind,
1659	SourceLocation KindKwLoc,
1660	SourceLocation StartLoc,
1661	SourceLocation LParenLoc,
1662	SourceLocation EndLoc) {
1663	return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1664	StartLoc, LParenLoc, EndLoc);
1665	}
1666
1667	/// Build a new OpenMP 'schedule' clause.
1668	///
1669	/// By default, performs semantic analysis to build the new OpenMP clause.
1670	/// Subclasses may override this routine to provide different behavior.
1671	OMPClause *RebuildOMPScheduleClause(
1672	OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1673	OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1674	SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1675	SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1676	return getSema().ActOnOpenMPScheduleClause(
1677	M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1678	CommaLoc, EndLoc);
1679	}
1680
1681	/// Build a new OpenMP 'ordered' clause.
1682	///
1683	/// By default, performs semantic analysis to build the new OpenMP clause.
1684	/// Subclasses may override this routine to provide different behavior.
1685	OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
1686	SourceLocation EndLoc,
1687	SourceLocation LParenLoc, Expr *Num) {
1688	return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1689	}
1690
1691	/// Build a new OpenMP 'private' clause.
1692	///
1693	/// By default, performs semantic analysis to build the new OpenMP clause.
1694	/// Subclasses may override this routine to provide different behavior.
1695	OMPClause RebuildOMPPrivateClause(ArrayRef<Expr > VarList,
1696	SourceLocation StartLoc,
1697	SourceLocation LParenLoc,
1698	SourceLocation EndLoc) {
1699	return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1700	EndLoc);
1701	}
1702
1703	/// Build a new OpenMP 'firstprivate' clause.
1704	///
1705	/// By default, performs semantic analysis to build the new OpenMP clause.
1706	/// Subclasses may override this routine to provide different behavior.
1707	OMPClause RebuildOMPFirstprivateClause(ArrayRef<Expr > VarList,
1708	SourceLocation StartLoc,
1709	SourceLocation LParenLoc,
1710	SourceLocation EndLoc) {
1711	return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1712	EndLoc);
1713	}
1714
1715	/// Build a new OpenMP 'lastprivate' clause.
1716	///
1717	/// By default, performs semantic analysis to build the new OpenMP clause.
1718	/// Subclasses may override this routine to provide different behavior.
1719	OMPClause RebuildOMPLastprivateClause(ArrayRef<Expr > VarList,
1720	OpenMPLastprivateModifier LPKind,
1721	SourceLocation LPKindLoc,
1722	SourceLocation ColonLoc,
1723	SourceLocation StartLoc,
1724	SourceLocation LParenLoc,
1725	SourceLocation EndLoc) {
1726	return getSema().ActOnOpenMPLastprivateClause(
1727	VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1728	}
1729
1730	/// Build a new OpenMP 'shared' clause.
1731	///
1732	/// By default, performs semantic analysis to build the new OpenMP clause.
1733	/// Subclasses may override this routine to provide different behavior.
1734	OMPClause RebuildOMPSharedClause(ArrayRef<Expr > VarList,
1735	SourceLocation StartLoc,
1736	SourceLocation LParenLoc,
1737	SourceLocation EndLoc) {
1738	return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1739	EndLoc);
1740	}
1741
1742	/// Build a new OpenMP 'reduction' clause.
1743	///
1744	/// By default, performs semantic analysis to build the new statement.
1745	/// Subclasses may override this routine to provide different behavior.
1746	OMPClause *RebuildOMPReductionClause(
1747	ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
1748	SourceLocation StartLoc, SourceLocation LParenLoc,
1749	SourceLocation ModifierLoc, SourceLocation ColonLoc,
1750	SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
1751	const DeclarationNameInfo &ReductionId,
1752	ArrayRef<Expr *> UnresolvedReductions) {
1753	return getSema().ActOnOpenMPReductionClause(
1754	VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1755	ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1756	}
1757
1758	/// Build a new OpenMP 'task_reduction' clause.
1759	///
1760	/// By default, performs semantic analysis to build the new statement.
1761	/// Subclasses may override this routine to provide different behavior.
1762	OMPClause *RebuildOMPTaskReductionClause(
1763	ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1764	SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
1765	CXXScopeSpec &ReductionIdScopeSpec,
1766	const DeclarationNameInfo &ReductionId,
1767	ArrayRef<Expr *> UnresolvedReductions) {
1768	return getSema().ActOnOpenMPTaskReductionClause(
1769	VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1770	ReductionId, UnresolvedReductions);
1771	}
1772
1773	/// Build a new OpenMP 'in_reduction' clause.
1774	///
1775	/// By default, performs semantic analysis to build the new statement.
1776	/// Subclasses may override this routine to provide different behavior.
1777	OMPClause *
1778	RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1779	SourceLocation LParenLoc, SourceLocation ColonLoc,
1780	SourceLocation EndLoc,
1781	CXXScopeSpec &ReductionIdScopeSpec,
1782	const DeclarationNameInfo &ReductionId,
1783	ArrayRef<Expr *> UnresolvedReductions) {
1784	return getSema().ActOnOpenMPInReductionClause(
1785	VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1786	ReductionId, UnresolvedReductions);
1787	}
1788
1789	/// Build a new OpenMP 'linear' clause.
1790	///
1791	/// By default, performs semantic analysis to build the new OpenMP clause.
1792	/// Subclasses may override this routine to provide different behavior.
1793	OMPClause RebuildOMPLinearClause(ArrayRef<Expr > VarList, Expr *Step,
1794	SourceLocation StartLoc,
1795	SourceLocation LParenLoc,
1796	OpenMPLinearClauseKind Modifier,
1797	SourceLocation ModifierLoc,
1798	SourceLocation ColonLoc,
1799	SourceLocation EndLoc) {
1800	return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1801	Modifier, ModifierLoc, ColonLoc,
1802	EndLoc);
1803	}
1804
1805	/// Build a new OpenMP 'aligned' clause.
1806	///
1807	/// By default, performs semantic analysis to build the new OpenMP clause.
1808	/// Subclasses may override this routine to provide different behavior.
1809	OMPClause RebuildOMPAlignedClause(ArrayRef<Expr > VarList, Expr *Alignment,
1810	SourceLocation StartLoc,
1811	SourceLocation LParenLoc,
1812	SourceLocation ColonLoc,
1813	SourceLocation EndLoc) {
1814	return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1815	LParenLoc, ColonLoc, EndLoc);
1816	}
1817
1818	/// Build a new OpenMP 'copyin' clause.
1819	///
1820	/// By default, performs semantic analysis to build the new OpenMP clause.
1821	/// Subclasses may override this routine to provide different behavior.
1822	OMPClause RebuildOMPCopyinClause(ArrayRef<Expr > VarList,
1823	SourceLocation StartLoc,
1824	SourceLocation LParenLoc,
1825	SourceLocation EndLoc) {
1826	return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1827	EndLoc);
1828	}
1829
1830	/// Build a new OpenMP 'copyprivate' clause.
1831	///
1832	/// By default, performs semantic analysis to build the new OpenMP clause.
1833	/// Subclasses may override this routine to provide different behavior.
1834	OMPClause RebuildOMPCopyprivateClause(ArrayRef<Expr > VarList,
1835	SourceLocation StartLoc,
1836	SourceLocation LParenLoc,
1837	SourceLocation EndLoc) {
1838	return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1839	EndLoc);
1840	}
1841
1842	/// Build a new OpenMP 'flush' pseudo clause.
1843	///
1844	/// By default, performs semantic analysis to build the new OpenMP clause.
1845	/// Subclasses may override this routine to provide different behavior.
1846	OMPClause RebuildOMPFlushClause(ArrayRef<Expr > VarList,
1847	SourceLocation StartLoc,
1848	SourceLocation LParenLoc,
1849	SourceLocation EndLoc) {
1850	return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1851	EndLoc);
1852	}
1853
1854	/// Build a new OpenMP 'depobj' pseudo clause.
1855	///
1856	/// By default, performs semantic analysis to build the new OpenMP clause.
1857	/// Subclasses may override this routine to provide different behavior.
1858	OMPClause RebuildOMPDepobjClause(Expr Depobj, SourceLocation StartLoc,
1859	SourceLocation LParenLoc,
1860	SourceLocation EndLoc) {
1861	return getSema().ActOnOpenMPDepobjClause(Depobj, StartLoc, LParenLoc,
1862	EndLoc);
1863	}
1864
1865	/// Build a new OpenMP 'depend' pseudo clause.
1866	///
1867	/// By default, performs semantic analysis to build the new OpenMP clause.
1868	/// Subclasses may override this routine to provide different behavior.
1869	OMPClause *
1870	RebuildOMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
1871	SourceLocation DepLoc, SourceLocation ColonLoc,
1872	ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1873	SourceLocation LParenLoc, SourceLocation EndLoc) {
1874	return getSema().ActOnOpenMPDependClause(DepModifier, DepKind, DepLoc,
1875	ColonLoc, VarList, StartLoc,
1876	LParenLoc, EndLoc);
1877	}
1878
1879	/// Build a new OpenMP 'device' clause.
1880	///
1881	/// By default, performs semantic analysis to build the new statement.
1882	/// Subclasses may override this routine to provide different behavior.
1883	OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
1884	Expr *Device, SourceLocation StartLoc,
1885	SourceLocation LParenLoc,
1886	SourceLocation ModifierLoc,
1887	SourceLocation EndLoc) {
1888	return getSema().ActOnOpenMPDeviceClause(Modifier, Device, StartLoc,
1889	LParenLoc, ModifierLoc, EndLoc);
1890	}
1891
1892	/// Build a new OpenMP 'map' clause.
1893	///
1894	/// By default, performs semantic analysis to build the new OpenMP clause.
1895	/// Subclasses may override this routine to provide different behavior.
1896	OMPClause *RebuildOMPMapClause(
1897	ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
1898	ArrayRef<SourceLocation> MapTypeModifiersLoc,
1899	CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId,
1900	OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
1901	SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1902	const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
1903	return getSema().ActOnOpenMPMapClause(MapTypeModifiers, MapTypeModifiersLoc,
1904	MapperIdScopeSpec, MapperId, MapType,
1905	IsMapTypeImplicit, MapLoc, ColonLoc,
1906	VarList, Locs, UnresolvedMappers);
1907	}
1908
1909	/// Build a new OpenMP 'allocate' clause.
1910	///
1911	/// By default, performs semantic analysis to build the new OpenMP clause.
1912	/// Subclasses may override this routine to provide different behavior.
1913	OMPClause RebuildOMPAllocateClause(Expr Allocate, ArrayRef<Expr *> VarList,
1914	SourceLocation StartLoc,
1915	SourceLocation LParenLoc,
1916	SourceLocation ColonLoc,
1917	SourceLocation EndLoc) {
1918	return getSema().ActOnOpenMPAllocateClause(Allocate, VarList, StartLoc,
1919	LParenLoc, ColonLoc, EndLoc);
1920	}
1921
1922	/// Build a new OpenMP 'num_teams' clause.
1923	///
1924	/// By default, performs semantic analysis to build the new statement.
1925	/// Subclasses may override this routine to provide different behavior.
1926	OMPClause RebuildOMPNumTeamsClause(Expr NumTeams, SourceLocation StartLoc,
1927	SourceLocation LParenLoc,
1928	SourceLocation EndLoc) {
1929	return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1930	EndLoc);
1931	}
1932
1933	/// Build a new OpenMP 'thread_limit' clause.
1934	///
1935	/// By default, performs semantic analysis to build the new statement.
1936	/// Subclasses may override this routine to provide different behavior.
1937	OMPClause RebuildOMPThreadLimitClause(Expr ThreadLimit,
1938	SourceLocation StartLoc,
1939	SourceLocation LParenLoc,
1940	SourceLocation EndLoc) {
1941	return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1942	LParenLoc, EndLoc);
1943	}
1944
1945	/// Build a new OpenMP 'priority' clause.
1946	///
1947	/// By default, performs semantic analysis to build the new statement.
1948	/// Subclasses may override this routine to provide different behavior.
1949	OMPClause RebuildOMPPriorityClause(Expr Priority, SourceLocation StartLoc,
1950	SourceLocation LParenLoc,
1951	SourceLocation EndLoc) {
1952	return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1953	EndLoc);
1954	}
1955
1956	/// Build a new OpenMP 'grainsize' clause.
1957	///
1958	/// By default, performs semantic analysis to build the new statement.
1959	/// Subclasses may override this routine to provide different behavior.
1960	OMPClause RebuildOMPGrainsizeClause(Expr Grainsize, SourceLocation StartLoc,
1961	SourceLocation LParenLoc,
1962	SourceLocation EndLoc) {
1963	return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1964	EndLoc);
1965	}
1966
1967	/// Build a new OpenMP 'num_tasks' clause.
1968	///
1969	/// By default, performs semantic analysis to build the new statement.
1970	/// Subclasses may override this routine to provide different behavior.
1971	OMPClause RebuildOMPNumTasksClause(Expr NumTasks, SourceLocation StartLoc,
1972	SourceLocation LParenLoc,
1973	SourceLocation EndLoc) {
1974	return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1975	EndLoc);
1976	}
1977
1978	/// Build a new OpenMP 'hint' clause.
1979	///
1980	/// By default, performs semantic analysis to build the new statement.
1981	/// Subclasses may override this routine to provide different behavior.
1982	OMPClause RebuildOMPHintClause(Expr Hint, SourceLocation StartLoc,
1983	SourceLocation LParenLoc,
1984	SourceLocation EndLoc) {
1985	return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1986	}
1987
1988	/// Build a new OpenMP 'detach' clause.
1989	///
1990	/// By default, performs semantic analysis to build the new statement.
1991	/// Subclasses may override this routine to provide different behavior.
1992	OMPClause RebuildOMPDetachClause(Expr Evt, SourceLocation StartLoc,
1993	SourceLocation LParenLoc,
1994	SourceLocation EndLoc) {
1995	return getSema().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc, EndLoc);
1996	}
1997
1998	/// Build a new OpenMP 'dist_schedule' clause.
1999	///
2000	/// By default, performs semantic analysis to build the new OpenMP clause.
2001	/// Subclasses may override this routine to provide different behavior.
2002	OMPClause *
2003	RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
2004	Expr *ChunkSize, SourceLocation StartLoc,
2005	SourceLocation LParenLoc, SourceLocation KindLoc,
2006	SourceLocation CommaLoc, SourceLocation EndLoc) {
2007	return getSema().ActOnOpenMPDistScheduleClause(
2008	Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2009	}
2010
2011	/// Build a new OpenMP 'to' clause.
2012	///
2013	/// By default, performs semantic analysis to build the new statement.
2014	/// Subclasses may override this routine to provide different behavior.
2015	OMPClause *
2016	RebuildOMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
2017	ArrayRef<SourceLocation> MotionModifiersLoc,
2018	CXXScopeSpec &MapperIdScopeSpec,
2019	DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
2020	ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2021	ArrayRef<Expr *> UnresolvedMappers) {
2022	return getSema().ActOnOpenMPToClause(MotionModifiers, MotionModifiersLoc,
2023	MapperIdScopeSpec, MapperId, ColonLoc,
2024	VarList, Locs, UnresolvedMappers);
2025	}
2026
2027	/// Build a new OpenMP 'from' clause.
2028	///
2029	/// By default, performs semantic analysis to build the new statement.
2030	/// Subclasses may override this routine to provide different behavior.
2031	OMPClause *
2032	RebuildOMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
2033	ArrayRef<SourceLocation> MotionModifiersLoc,
2034	CXXScopeSpec &MapperIdScopeSpec,
2035	DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
2036	ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2037	ArrayRef<Expr *> UnresolvedMappers) {
2038	return getSema().ActOnOpenMPFromClause(
2039	MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2040	ColonLoc, VarList, Locs, UnresolvedMappers);
2041	}
2042
2043	/// Build a new OpenMP 'use_device_ptr' clause.
2044	///
2045	/// By default, performs semantic analysis to build the new OpenMP clause.
2046	/// Subclasses may override this routine to provide different behavior.
2047	OMPClause RebuildOMPUseDevicePtrClause(ArrayRef<Expr > VarList,
2048	const OMPVarListLocTy &Locs) {
2049	return getSema().ActOnOpenMPUseDevicePtrClause(VarList, Locs);
2050	}
2051
2052	/// Build a new OpenMP 'use_device_addr' clause.
2053	///
2054	/// By default, performs semantic analysis to build the new OpenMP clause.
2055	/// Subclasses may override this routine to provide different behavior.
2056	OMPClause RebuildOMPUseDeviceAddrClause(ArrayRef<Expr > VarList,
2057	const OMPVarListLocTy &Locs) {
2058	return getSema().ActOnOpenMPUseDeviceAddrClause(VarList, Locs);
2059	}
2060
2061	/// Build a new OpenMP 'is_device_ptr' clause.
2062	///
2063	/// By default, performs semantic analysis to build the new OpenMP clause.
2064	/// Subclasses may override this routine to provide different behavior.
2065	OMPClause RebuildOMPIsDevicePtrClause(ArrayRef<Expr > VarList,
2066	const OMPVarListLocTy &Locs) {
2067	return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
2068	}
2069
2070	/// Build a new OpenMP 'defaultmap' clause.
2071	///
2072	/// By default, performs semantic analysis to build the new OpenMP clause.
2073	/// Subclasses may override this routine to provide different behavior.
2074	OMPClause *RebuildOMPDefaultmapClause(OpenMPDefaultmapClauseModifier M,
2075	OpenMPDefaultmapClauseKind Kind,
2076	SourceLocation StartLoc,
2077	SourceLocation LParenLoc,
2078	SourceLocation MLoc,
2079	SourceLocation KindLoc,
2080	SourceLocation EndLoc) {
2081	return getSema().ActOnOpenMPDefaultmapClause(M, Kind, StartLoc, LParenLoc,
2082	MLoc, KindLoc, EndLoc);
2083	}
2084
2085	/// Build a new OpenMP 'nontemporal' clause.
2086	///
2087	/// By default, performs semantic analysis to build the new OpenMP clause.
2088	/// Subclasses may override this routine to provide different behavior.
2089	OMPClause RebuildOMPNontemporalClause(ArrayRef<Expr > VarList,
2090	SourceLocation StartLoc,
2091	SourceLocation LParenLoc,
2092	SourceLocation EndLoc) {
2093	return getSema().ActOnOpenMPNontemporalClause(VarList, StartLoc, LParenLoc,
2094	EndLoc);
2095	}
2096
2097	/// Build a new OpenMP 'inclusive' clause.
2098	///
2099	/// By default, performs semantic analysis to build the new OpenMP clause.
2100	/// Subclasses may override this routine to provide different behavior.
2101	OMPClause RebuildOMPInclusiveClause(ArrayRef<Expr > VarList,
2102	SourceLocation StartLoc,
2103	SourceLocation LParenLoc,
2104	SourceLocation EndLoc) {
2105	return getSema().ActOnOpenMPInclusiveClause(VarList, StartLoc, LParenLoc,
2106	EndLoc);
2107	}
2108
2109	/// Build a new OpenMP 'exclusive' clause.
2110	///
2111	/// By default, performs semantic analysis to build the new OpenMP clause.
2112	/// Subclasses may override this routine to provide different behavior.
2113	OMPClause RebuildOMPExclusiveClause(ArrayRef<Expr > VarList,
2114	SourceLocation StartLoc,
2115	SourceLocation LParenLoc,
2116	SourceLocation EndLoc) {
2117	return getSema().ActOnOpenMPExclusiveClause(VarList, StartLoc, LParenLoc,
2118	EndLoc);
2119	}
2120
2121	/// Build a new OpenMP 'uses_allocators' clause.
2122	///
2123	/// By default, performs semantic analysis to build the new OpenMP clause.
2124	/// Subclasses may override this routine to provide different behavior.
2125	OMPClause *RebuildOMPUsesAllocatorsClause(
2126	ArrayRef<Sema::UsesAllocatorsData> Data, SourceLocation StartLoc,
2127	SourceLocation LParenLoc, SourceLocation EndLoc) {
2128	return getSema().ActOnOpenMPUsesAllocatorClause(StartLoc, LParenLoc, EndLoc,
2129	Data);
2130	}
2131
2132	/// Build a new OpenMP 'affinity' clause.
2133	///
2134	/// By default, performs semantic analysis to build the new OpenMP clause.
2135	/// Subclasses may override this routine to provide different behavior.
2136	OMPClause *RebuildOMPAffinityClause(SourceLocation StartLoc,
2137	SourceLocation LParenLoc,
2138	SourceLocation ColonLoc,
2139	SourceLocation EndLoc, Expr *Modifier,
2140	ArrayRef<Expr *> Locators) {
2141	return getSema().ActOnOpenMPAffinityClause(StartLoc, LParenLoc, ColonLoc,
2142	EndLoc, Modifier, Locators);
2143	}
2144
2145	/// Build a new OpenMP 'order' clause.
2146	///
2147	/// By default, performs semantic analysis to build the new OpenMP clause.
2148	/// Subclasses may override this routine to provide different behavior.
2149	OMPClause *RebuildOMPOrderClause(OpenMPOrderClauseKind Kind,
2150	SourceLocation KindKwLoc,
2151	SourceLocation StartLoc,
2152	SourceLocation LParenLoc,
2153	SourceLocation EndLoc) {
2154	return getSema().ActOnOpenMPOrderClause(Kind, KindKwLoc, StartLoc,
2155	LParenLoc, EndLoc);
2156	}
2157
2158	/// Rebuild the operand to an Objective-C \@synchronized statement.
2159	///
2160	/// By default, performs semantic analysis to build the new statement.
2161	/// Subclasses may override this routine to provide different behavior.
2162	ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
2163	Expr *object) {
2164	return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
2165	}
2166
2167	/// Build a new Objective-C \@synchronized statement.
2168	///
2169	/// By default, performs semantic analysis to build the new statement.
2170	/// Subclasses may override this routine to provide different behavior.
2171	StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,