/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp

Bug Summary

File:	clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:	line 2793, column 41 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -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 -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/build-llvm/tools/clang/lib/Sema -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema -I /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include -I /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d=. -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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-05-07-005843-9350-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp

/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/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?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
 "No variable template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No variable template?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 88, __extension__ __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?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
 "No class template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No class template?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 133, __extension__ __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?")(static_cast <bool> (Function->getPrimaryTemplate() &&
 "No function template?") ? void (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 156, __extension__ __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-13~++20210506100649+6304c0836a4d/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() &&
37
←
Assuming the condition is false→
    SemaRef.hasUncompilableErrorOccurred()) {
  Invalid = true;
  return;
}
Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
38
←
Calling 'InstantiatingTemplate::CheckInstantiationDepth'→
44
←
Returning from 'InstantiatingTemplate::CheckInstantiationDepth'→
if (!Invalid44.1
Field 'Invalid' is false
1
Field 'Invalid' is false
) {
45
←
Taking true branch→
  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.Entity45.1
Field 'Entity' is non-null
1
Field 'Entity' is non-null
 ? false :
46
←
'?' condition is false→
      !SemaRef.InstantiatingSpecializations
47
←
Assuming field 'second' is true→
           .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,
36
←
Calling constructor for 'InstantiatingTemplate'→
48
←
Returning from constructor for 'InstantiatingTemplate'→
                          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((static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 305, __extension__ __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 305, __extension__ __PRETTY_FUNCTION__))
  Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
 || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 305, __extension__ __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)(static_cast <bool> (NonInstantiationEntries > 0) ? void
 (0) : __assert_fail ("NonInstantiationEntries > 0", "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 451, __extension__ __PRETTY_FUNCTION__));
  --NonInstantiationEntries;
}

InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;

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

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

CodeSynthesisContexts.pop_back();
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 <=(static_cast <bool> (SemaRef.NonInstantiationEntries <=
 SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
 ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 498, __extension__ __PRETTY_FUNCTION__))
39
←
Assuming the condition is true→
40
←
'?' condition is true→
       SemaRef.CodeSynthesisContexts.size())(static_cast <bool> (SemaRef.NonInstantiationEntries <=
 SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
 ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 498, __extension__ __PRETTY_FUNCTION__));
if ((SemaRef.CodeSynthesisContexts.size() -
41
←
Assuming the condition is true→
42
←
Taking true branch→
        SemaRef.NonInstantiationEntries)
      <= SemaRef.getLangOpts().InstantiationDepth)
  return false;
43
←
Returning zero, which participates in a condition later→

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-13~++20210506100649+6304c0836a4d/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))(static_cast <bool> (isa<FunctionDecl>(Active->
Entity)) ? void (0) : __assert_fail ("isa<FunctionDecl>(Active->Entity)"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 802, __extension__ __PRETTY_FUNCTION__));
      DiagID = diag::note_checking_constraints_for_function_here;
    }
    SmallString<128> TemplateArgsStr;
    llvm::raw_svector_ostream OS(TemplateArgsStr);
    cast<NamedDecl>(Active->Entity)->printName(OS);
    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")(static_cast <bool> (Active->DeductionInfo &&
 "Missing deduction info pointer") ? void (0) : __assert_fail
 ("Active->DeductionInfo && \"Missing deduction info pointer\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 877, __extension__ __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 &&(static_cast <bool> (NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? void (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1017, __extension__ __PRETTY_FUNCTION__))
           "should only have multiple expansions for a pack")(static_cast <bool> (NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? void (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1017, __extension__ __PRETTY_FUNCTION__));
    Decl *New = NewDecls.front();

    // If we've instantiated the call operator of a lambda or the call
    // operator template of a generic lambda, update the "instantiation of"
    // information.
    auto *NewMD = dyn_cast<CXXMethodDecl>(New);
    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);
  }

  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)(static_cast <bool> (S.ArgumentPackSubstitutionIndex >=
 0) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1207, __extension__ __PRETTY_FUNCTION__));
assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())(static_cast <bool> (S.ArgumentPackSubstitutionIndex <
 (int)Arg.pack_size()) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1208, __extension__ __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 &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1233, __extension__ __PRETTY_FUNCTION__))
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1233, __extension__ __PRETTY_FUNCTION__));
      Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
    }

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && Template.getAsTemplateDecl() &&(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1239, __extension__ __PRETTY_FUNCTION__))
           "Wrong kind of template template argument")(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1239, __extension__ __PRETTY_FUNCTION__));
    return Template.getAsTemplateDecl();
  }

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

return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
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 &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1274, __extension__ __PRETTY_FUNCTION__))
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1274, __extension__ __PRETTY_FUNCTION__));

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

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

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

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

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

return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
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() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1375, __extension__ __PRETTY_FUNCTION__))
               "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1375, __extension__ __PRETTY_FUNCTION__));
        Arg = Arg.pack_begin()->getPackExpansionPattern();
      }
      assert(Arg.getKind() == TemplateArgument::Template &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Template && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1379, __extension__ __PRETTY_FUNCTION__))
             "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Template && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1379, __extension__ __PRETTY_FUNCTION__));
      return Arg.getAsTemplate();
    }

    if (TTP->isParameterPack()) {
      assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1385, __extension__ __PRETTY_FUNCTION__))
             "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1385, __extension__ __PRETTY_FUNCTION__));

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

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

    TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
    assert(!Template.isNull() && "Null template template argument")(static_cast <bool> (!Template.isNull() && "Null template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1398, __extension__ __PRETTY_FUNCTION__));
    assert(!Template.getAsQualifiedTemplateName() &&(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
 (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1400, __extension__ __PRETTY_FUNCTION__))
           "template decl to substitute is qualified?")(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
 (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1400, __extension__ __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() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1448, __extension__ __PRETTY_FUNCTION__))
           "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1448, __extension__ __PRETTY_FUNCTION__));
    Arg = Arg.pack_begin()->getPackExpansionPattern();
  }
  assert(Arg.getKind() == TemplateArgument::Expression &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1452, __extension__ __PRETTY_FUNCTION__))
         "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1452, __extension__ __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 &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1460, __extension__ __PRETTY_FUNCTION__))
         "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1460, __extension__ __PRETTY_FUNCTION__));

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

    QualType ExprType = TargetType.getNonLValueExprType(SemaRef.Context);
    if (TargetType->isRecordType())
      ExprType.addConst();

    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")(static_cast <bool> (!paramType.isNull() && "type substitution failed for param type"
) ? void (0) : __assert_fail ("!paramType.isNull() && \"type substitution failed for param type\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1560, __extension__ __PRETTY_FUNCTION__));
  assert(!paramType->isDependentType() && "param type still dependent")(static_cast <bool> (!paramType->isDependentType() &&
 "param type still dependent") ? void (0) : __assert_fail ("!paramType->isDependentType() && \"param type still dependent\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1561, __extension__ __PRETTY_FUNCTION__));
  result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, paramType, loc);
  refParam = paramType->isReferenceType();
} else {
  result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
  assert(result.isInvalid() ||(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1568, __extension__ __PRETTY_FUNCTION__))
         SemaRef.Context.hasSameType(result.get()->getType(),(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1568, __extension__ __PRETTY_FUNCTION__))
                                     arg.getIntegralType()))(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1568, __extension__ __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 = E->getReplacement();
if (!isa<ConstantExpr>(SubstReplacement.get()))
  SubstReplacement = TransformExpr(E->getReplacement());
if (SubstReplacement.isInvalid())
  return true;
QualType SubstType = TransformType(E->getParameterType(getSema().Context));
if (SubstType.isNull())
  return true;
// The type may have been previously dependent and not now, which means we
// might have to implicit cast the argument to the new type, for example:
// template<auto T, decltype(T) U>
// concept C = sizeof(U) == 4;
// void foo() requires C<2, 'a'> { }
// When normalizing foo(), we first form the normalized constraints of C:
// AtomicExpr(sizeof(U) == 4,
//            U=SubstNonTypeTemplateParmExpr(Param=U,
//                                           Expr=DeclRef(U),
//                                           Type=decltype(T)))
// Then we substitute T = 2, U = 'a' into the parameter mapping, and need to
// produce:
// AtomicExpr(sizeof(U) == 4,
//            U=SubstNonTypeTemplateParmExpr(Param=U,
//                                           Expr=ImpCast(
//                                               decltype(2),
//                                               SubstNTTPE(Param=U, Expr='a',
//                                                          Type=char)),
//                                           Type=decltype(2)))
// The call to CheckTemplateArgument here produces the ImpCast.
TemplateArgument Converted;
if (SemaRef.CheckTemplateArgument(E->getParameter(), SubstType,
                                  SubstReplacement.get(),
                                  Converted).isInvalid())
  return true;
return transformNonTypeTemplateParmRef(E->getParameter(),
                                       E->getExprLoc(), Converted);
1633}

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

1641ExprResult
1642TemplateInstantiator::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;
1673}

1675ExprResult
1676TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
                                                     VarDecl *PD) {
typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
  = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
assert(Found && "no instantiation for parameter pack")(static_cast <bool> (Found && "no instantiation for parameter pack"
) ? void (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1681, __extension__ __PRETTY_FUNCTION__));

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

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

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

1706ExprResult
1707TemplateInstantiator::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);
1726}

1728ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
  CXXDefaultArgExpr *E) {
assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1732, __extension__ __PRETTY_FUNCTION__))
           getDescribedFunctionTemplate() &&(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1732, __extension__ __PRETTY_FUNCTION__))
       "Default arg expressions are never formed in dependent cases.")(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
 "Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1732, __extension__ __PRETTY_FUNCTION__));
return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
                         cast<FunctionDecl>(E->getParam()->getDeclContext()),
                                      E->getParam());
1736}

1738template<typename Fn>
1739QualType 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);
1748}

1750ParmVarDecl *
1751TemplateInstantiator::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;
1761}

1763QualType
1764TemplateInstantiator::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() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1789, __extension__ __PRETTY_FUNCTION__))
             "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1789, __extension__ __PRETTY_FUNCTION__));
      Arg = Arg.pack_begin()->getPackExpansionPattern();
    }
    assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1793, __extension__ __PRETTY_FUNCTION__))
           "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1793, __extension__ __PRETTY_FUNCTION__));
    QualType NewT = Arg.getAsType();
    assert(isa<TemplateTypeParmType>(NewT) &&(static_cast <bool> (isa<TemplateTypeParmType>(NewT
) && "type parm not rewritten to type parm") ? void (
0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1796, __extension__ __PRETTY_FUNCTION__))
           "type parm not rewritten to type parm")(static_cast <bool> (isa<TemplateTypeParmType>(NewT
) && "type parm not rewritten to type parm") ? void (
0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1796, __extension__ __PRETTY_FUNCTION__));
    auto NewTL = TLB.push<TemplateTypeParmTypeLoc>(NewT);
    NewTL.setNameLoc(TL.getNameLoc());
    return NewT;
  }

  if (T->isParameterPack()) {
    assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1804, __extension__ __PRETTY_FUNCTION__))
           "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
 ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1804, __extension__ __PRETTY_FUNCTION__));

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

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

  assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
 : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1822, __extension__ __PRETTY_FUNCTION__))
         "Template argument kind mismatch")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
 : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1822, __extension__ __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;
1850}

1852QualType
1853TemplateInstantiator::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;
1875}

1877template<typename EntityPrinter>
1878static concepts::Requirement::SubstitutionDiagnostic *
1879createSubstDiag(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())};
1901}

1903concepts::TypeRequirement *
1904TemplateInstantiator::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);
1928}

1930concepts::ExprRequirement *
1931TemplateInstantiator::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() &&(static_cast <bool> (TransRetReq.hasValue() && "All code paths leading here must set TransRetReq"
) ? void (0) : __assert_fail ("TransRetReq.hasValue() && \"All code paths leading here must set TransRetReq\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1986, __extension__ __PRETTY_FUNCTION__))
       "All code paths leading here must set TransRetReq")(static_cast <bool> (TransRetReq.hasValue() && "All code paths leading here must set TransRetReq"
) ? void (0) : __assert_fail ("TransRetReq.hasValue() && \"All code paths leading here must set TransRetReq\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1986, __extension__ __PRETTY_FUNCTION__));
if (Expr *E = TransExpr.dyn_cast<Expr *>())
  return RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(),
                                std::move(*TransRetReq));
return RebuildExprRequirement(
    TransExpr.get<concepts::Requirement::SubstitutionDiagnostic *>(),
    Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
1993}

1995concepts::NestedRequirement *
1996TemplateInstantiator::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());
2031}


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

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

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

2082TypeSourceInfo *Sema::SubstType(TypeLoc TL,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2088, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2088, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2088, __extension__ __PRETTY_FUNCTION__));

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

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

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

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

2112/// Deprecated form of the above.
2113QualType Sema::SubstType(QualType T,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SourceLocation Loc, DeclarationName Entity) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2118, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2118, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2118, __extension__ __PRETTY_FUNCTION__));

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

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

2129static 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;
2149}

2151/// A form of SubstType intended specifically for instantiating the
2152/// type of a FunctionDecl.  Its purpose is solely to force the
2153/// instantiation of default-argument expressions and to avoid
2154/// instantiating an exception-specification.
2155TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
                              const MultiLevelTemplateArgumentList &Args,
                              SourceLocation Loc,
                              DeclarationName Entity,
                              CXXRecordDecl *ThisContext,
                              Qualifiers ThisTypeQuals) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2163, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2163, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2163, __extension__ __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);
2195}

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

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

2209void 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);
2221}

2223namespace {

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

2309} // namespace

2311ParmVarDecl *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;
2460}

2462/// Substitute the given template arguments into the given set of
2463/// parameters, producing the set of parameter types that would be generated
2464/// from such a substitution.
2465bool Sema::SubstParmTypes(
  SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
  const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
  const MultiLevelTemplateArgumentList &TemplateArgs,
  SmallVectorImpl<QualType> &ParamTypes,
  SmallVectorImpl<ParmVarDecl *> *OutParams,
  ExtParameterInfoBuilder &ParamInfos) {
assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2474, __extension__ __PRETTY_FUNCTION__))
       "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2474, __extension__ __PRETTY_FUNCTION__))
       "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
 "Cannot perform an instantiation without some context on the "
 "instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2474, __extension__ __PRETTY_FUNCTION__));

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

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

2591// Defined via #include from SemaTemplateInstantiateDecl.cpp
2592namespace 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);
}
2600}

2602/// Instantiate the definition of a class from a given pattern.
2603///
2604/// \param PointOfInstantiation The point of instantiation within the
2605/// source code.
2606///
2607/// \param Instantiation is the declaration whose definition is being
2608/// instantiated. This will be either a class template specialization
2609/// or a member class of a class template specialization.
2610///
2611/// \param Pattern is the pattern from which the instantiation
2612/// occurs. This will be either the declaration of a class template or
2613/// the declaration of a member class of a class template.
2614///
2615/// \param TemplateArgs The template arguments to be substituted into
2616/// the pattern.
2617///
2618/// \param TSK the kind of implicit or explicit instantiation to perform.
2619///
2620/// \param Complain whether to complain if the class cannot be instantiated due
2621/// to the lack of a definition.
2622///
2623/// \returns true if an error occurred, false otherwise.
2624bool
2625Sema::InstantiateClass(SourceLocation PointOfInstantiation,
                     CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
                     const MultiLevelTemplateArgumentList &TemplateArgs,
                     TemplateSpecializationKind TSK,
                     bool Complain) {
CXXRecordDecl *PatternDef
  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
28
←
Assuming the object is a 'CXXRecordDecl'→
if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
29
←
Assuming the condition is false→
30
←
Taking false branch→
                              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
31
←
Assuming 'MSInfo' is null→
32
←
Taking false branch→
      = Instantiation->getMemberSpecializationInfo()) {
  MSInfo->setTemplateSpecializationKind(TSK);
  MSInfo->setPointOfInstantiation(PointOfInstantiation);
} else if (ClassTemplateSpecializationDecl *Spec33.1
'Spec' is null

33.1	'Spec' is null

←

Taking false branch

→

2653 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {

←

Assuming 'Instantiation' is not a 'ClassTemplateSpecializationDecl'

→

2654 Spec->setTemplateSpecializationKind(TSK); 2655 Spec->setPointOfInstantiation(PointOfInstantiation); 2656 } 2657 2658 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);

←

Calling constructor for 'InstantiatingTemplate'

→

←

Returning from constructor for 'InstantiatingTemplate'

→

2659 if (Inst.isInvalid())

←

Calling 'InstantiatingTemplate::isInvalid'

→

←

Returning from 'InstantiatingTemplate::isInvalid'

→

←

Taking false branch

→

2660 return true; 2661 assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller")(static_cast <bool> (!Inst.isAlreadyInstantiating() &&
"should have been caught by caller") ? void (0) : __assert_fail
("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2661, __extension__ __PRETTY_FUNCTION__));

←

'?' condition is true

→

2662 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(), 2663 "instantiating class definition"); 2664 2665 // Enter the scope of this instantiation. We don't use 2666 // PushDeclContext because we don't have a scope. 2667 ContextRAII SavedContext(*this, Instantiation); 2668 EnterExpressionEvaluationContext EvalContext( 2669 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 2670 2671 // If this is an instantiation of a local class, merge this local 2672 // instantiation scope with the enclosing scope. Otherwise, every 2673 // instantiation of a class has its own local instantiation scope. 2674 bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod(); 2675 LocalInstantiationScope Scope(*this, MergeWithParentScope); 2676 2677 // Some class state isn't processed immediately but delayed till class 2678 // instantiation completes. We may not be ready to handle any delayed state 2679 // already on the stack as it might correspond to a different class, so save 2680 // it now and put it back later. 2681 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this); 2682 2683 // Pull attributes from the pattern onto the instantiation. 2684 InstantiateAttrs(TemplateArgs, Pattern, Instantiation); 2685 2686 // Start the definition of this instantiation. 2687 Instantiation->startDefinition(); 2688 2689 // The instantiation is visible here, even if it was first declared in an 2690 // unimported module. 2691 Instantiation->setVisibleDespiteOwningModule(); 2692 2693 // FIXME: This loses the as-written tag kind for an explicit instantiation. 2694 Instantiation->setTagKind(Pattern->getTagKind()); 2695 2696 // Do substitution on the base class specifiers. 2697 if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))

←

Taking false branch

→

2698 Instantiation->setInvalidDecl(); 2699 2700 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs); 2701 SmallVector<Decl*, 4> Fields; 2702 // Delay instantiation of late parsed attributes. 2703 LateInstantiatedAttrVec LateAttrs; 2704 Instantiator.enableLateAttributeInstantiation(&LateAttrs); 2705 2706 bool MightHaveConstexprVirtualFunctions = false; 2707 for (auto *Member : Pattern->decls()) { 2708 // Don't instantiate members not belonging in this semantic context. 2709 // e.g. for: 2710 // @code 2711 // template <int i> class A { 2712 // class B *g; 2713 // }; 2714 // @endcode 2715 // 'class B' has the template as lexical context but semantically it is 2716 // introduced in namespace scope. 2717 if (Member->getDeclContext() != Pattern) 2718 continue; 2719 2720 // BlockDecls can appear in a default-member-initializer. They must be the 2721 // child of a BlockExpr, so we only know how to instantiate them from there. 2722 // Similarly, lambda closure types are recreated when instantiating the 2723 // corresponding LambdaExpr. 2724 if (isa<BlockDecl>(Member) || 2725 (isa<CXXRecordDecl>(Member) && cast<CXXRecordDecl>(Member)->isLambda())) 2726 continue; 2727 2728 if (Member->isInvalidDecl()) { 2729 Instantiation->setInvalidDecl(); 2730 continue; 2731 } 2732 2733 Decl *NewMember = Instantiator.Visit(Member); 2734 if (NewMember) { 2735 if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) { 2736 Fields.push_back(Field); 2737 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) { 2738 // C++11 [temp.inst]p1: The implicit instantiation of a class template 2739 // specialization causes the implicit instantiation of the definitions 2740 // of unscoped member enumerations. 2741 // Record a point of instantiation for this implicit instantiation. 2742 if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() && 2743 Enum->isCompleteDefinition()) { 2744 MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo(); 2745 assert(MSInfo && "no spec info for member enum specialization")(static_cast <bool> (MSInfo && "no spec info for member enum specialization"
) ? void (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2745, __extension__ __PRETTY_FUNCTION__)); 2746 MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation); 2747 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2748 } 2749 } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) { 2750 if (SA->isFailed()) { 2751 // A static_assert failed. Bail out; instantiating this 2752 // class is probably not meaningful. 2753 Instantiation->setInvalidDecl(); 2754 break; 2755 } 2756 } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) { 2757 if (MD->isConstexpr() && !MD->getFriendObjectKind() && 2758 (MD->isVirtualAsWritten() || Instantiation->getNumBases())) 2759 MightHaveConstexprVirtualFunctions = true; 2760 } 2761 2762 if (NewMember->isInvalidDecl()) 2763 Instantiation->setInvalidDecl(); 2764 } else { 2765 // FIXME: Eventually, a NULL return will mean that one of the 2766 // instantiations was a semantic disaster, and we'll want to mark the 2767 // declaration invalid. 2768 // For now, we expect to skip some members that we can't yet handle. 2769 } 2770 } 2771 2772 // Finish checking fields. 2773 ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields, 2774 SourceLocation(), SourceLocation(), ParsedAttributesView()); 2775 CheckCompletedCXXClass(nullptr, Instantiation); 2776 2777 // Default arguments are parsed, if not instantiated. We can go instantiate 2778 // default arg exprs for default constructors if necessary now. Unless we're 2779 // parsing a class, in which case wait until that's finished. 2780 if (ParsingClassDepth == 0)

←

Assuming field 'ParsingClassDepth' is not equal to 0

→

←

Taking false branch

→

2781 ActOnFinishCXXNonNestedClass(); 2782 2783 // Instantiate late parsed attributes, and attach them to their decls. 2784 // See Sema::InstantiateAttrs 2785 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),

←

Loop condition is true. Entering loop body

→

2786 E = LateAttrs.end(); I != E; ++I) {

←

Assuming 'I' is not equal to 'E'

→

2787 assert(CurrentInstantiationScope == Instantiator.getStartingScope())(static_cast <bool> (CurrentInstantiationScope == Instantiator
.getStartingScope()) ? void (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2787, __extension__ __PRETTY_FUNCTION__));

←

Assuming the condition is true

→

←

'?' condition is true

→

2788 CurrentInstantiationScope = I->Scope; 2789 2790 // Allow 'this' within late-parsed attributes. 2791 NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);

←

Assuming field 'NewDecl' is not a 'NamedDecl'

→

←

'ND' initialized to a null pointer value

→

2792 CXXRecordDecl *ThisContext = 2793 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());

←

Called C++ object pointer is null

2794 CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(), 2795 ND && ND->isCXXInstanceMember()); 2796 2797 Attr *NewAttr = 2798 instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs); 2799 if (NewAttr) 2800 I->NewDecl->addAttr(NewAttr); 2801 LocalInstantiationScope::deleteScopes(I->Scope, 2802 Instantiator.getStartingScope()); 2803 } 2804 Instantiator.disableLateAttributeInstantiation(); 2805 LateAttrs.clear(); 2806 2807 ActOnFinishDelayedMemberInitializers(Instantiation); 2808 2809 // FIXME: We should do something similar for explicit instantiations so they 2810 // end up in the right module. 2811 if (TSK == TSK_ImplicitInstantiation) { 2812 Instantiation->setLocation(Pattern->getLocation()); 2813 Instantiation->setLocStart(Pattern->getInnerLocStart()); 2814 Instantiation->setBraceRange(Pattern->getBraceRange()); 2815 } 2816 2817 if (!Instantiation->isInvalidDecl()) { 2818 // Perform any dependent diagnostics from the pattern. 2819 PerformDependentDiagnostics(Pattern, TemplateArgs); 2820 2821 // Instantiate any out-of-line class template partial 2822 // specializations now. 2823 for (TemplateDeclInstantiator::delayed_partial_spec_iterator 2824 P = Instantiator.delayed_partial_spec_begin(), 2825 PEnd = Instantiator.delayed_partial_spec_end(); 2826 P != PEnd; ++P) { 2827 if (!Instantiator.InstantiateClassTemplatePartialSpecialization( 2828 P->first, P->second)) { 2829 Instantiation->setInvalidDecl(); 2830 break; 2831 } 2832 } 2833 2834 // Instantiate any out-of-line variable template partial 2835 // specializations now. 2836 for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator 2837 P = Instantiator.delayed_var_partial_spec_begin(), 2838 PEnd = Instantiator.delayed_var_partial_spec_end(); 2839 P != PEnd; ++P) { 2840 if (!Instantiator.InstantiateVarTemplatePartialSpecialization( 2841 P->first, P->second)) { 2842 Instantiation->setInvalidDecl(); 2843 break; 2844 } 2845 } 2846 } 2847 2848 // Exit the scope of this instantiation. 2849 SavedContext.pop(); 2850 2851 if (!Instantiation->isInvalidDecl()) { 2852 // Always emit the vtable for an explicit instantiation definition 2853 // of a polymorphic class template specialization. Otherwise, eagerly 2854 // instantiate only constexpr virtual functions in preparation for their use 2855 // in constant evaluation. 2856 if (TSK == TSK_ExplicitInstantiationDefinition) 2857 MarkVTableUsed(PointOfInstantiation, Instantiation, true); 2858 else if (MightHaveConstexprVirtualFunctions) 2859 MarkVirtualMembersReferenced(PointOfInstantiation, Instantiation, 2860 /*ConstexprOnly*/ true); 2861 } 2862 2863 Consumer.HandleTagDeclDefinition(Instantiation); 2864 2865 return Instantiation->isInvalidDecl(); 2866} 2867 2868/// Instantiate the definition of an enum from a given pattern. 2869/// 2870/// \param PointOfInstantiation The point of instantiation within the 2871/// source code. 2872/// \param Instantiation is the declaration whose definition is being 2873/// instantiated. This will be a member enumeration of a class 2874/// temploid specialization, or a local enumeration within a 2875/// function temploid specialization. 2876/// \param Pattern The templated declaration from which the instantiation 2877/// occurs. 2878/// \param TemplateArgs The template arguments to be substituted into 2879/// the pattern. 2880/// \param TSK The kind of implicit or explicit instantiation to perform. 2881/// 2882/// \return \c true if an error occurred, \c false otherwise. 2883bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation, 2884 EnumDecl *Instantiation, EnumDecl *Pattern, 2885 const MultiLevelTemplateArgumentList &TemplateArgs, 2886 TemplateSpecializationKind TSK) { 2887 EnumDecl *PatternDef = Pattern->getDefinition(); 2888 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation, 2889 Instantiation->getInstantiatedFromMemberEnum(), 2890 Pattern, PatternDef, TSK,/*Complain*/true)) 2891 return true; 2892 Pattern = PatternDef; 2893 2894 // Record the point of instantiation. 2895 if (MemberSpecializationInfo *MSInfo 2896 = Instantiation->getMemberSpecializationInfo()) { 2897 MSInfo->setTemplateSpecializationKind(TSK); 2898 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2899 } 2900 2901 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 2902 if (Inst.isInvalid()) 2903 return true; 2904 if (Inst.isAlreadyInstantiating()) 2905 return false; 2906 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(), 2907 "instantiating enum definition"); 2908 2909 // The instantiation is visible here, even if it was first declared in an 2910 // unimported module. 2911 Instantiation->setVisibleDespiteOwningModule(); 2912 2913 // Enter the scope of this instantiation. We don't use 2914 // PushDeclContext because we don't have a scope. 2915 ContextRAII SavedContext(*this, Instantiation); 2916 EnterExpressionEvaluationContext EvalContext( 2917 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 2918 2919 LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true); 2920 2921 // Pull attributes from the pattern onto the instantiation. 2922 InstantiateAttrs(TemplateArgs, Pattern, Instantiation); 2923 2924 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs); 2925 Instantiator.InstantiateEnumDefinition(Instantiation, Pattern); 2926 2927 // Exit the scope of this instantiation. 2928 SavedContext.pop(); 2929 2930 return Instantiation->isInvalidDecl(); 2931} 2932 2933 2934/// Instantiate the definition of a field from the given pattern. 2935/// 2936/// \param PointOfInstantiation The point of instantiation within the 2937/// source code. 2938/// \param Instantiation is the declaration whose definition is being 2939/// instantiated. This will be a class of a class temploid 2940/// specialization, or a local enumeration within a function temploid 2941/// specialization. 2942/// \param Pattern The templated declaration from which the instantiation 2943/// occurs. 2944/// \param TemplateArgs The template arguments to be substituted into 2945/// the pattern. 2946/// 2947/// \return \c true if an error occurred, \c false otherwise. 2948bool Sema::InstantiateInClassInitializer( 2949 SourceLocation PointOfInstantiation, FieldDecl *Instantiation, 2950 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) { 2951 // If there is no initializer, we don't need to do anything. 2952 if (!Pattern->hasInClassInitializer()) 2953 return false; 2954 2955 assert(Instantiation->getInClassInitStyle() ==(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2957, __extension__ __PRETTY_FUNCTION__)) 2956 Pattern->getInClassInitStyle() &&(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2957, __extension__ __PRETTY_FUNCTION__)) 2957 "pattern and instantiation disagree about init style")(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2957, __extension__ __PRETTY_FUNCTION__)); 2958 2959 // Error out if we haven't parsed the initializer of the pattern yet because 2960 // we are waiting for the closing brace of the outer class. 2961 Expr *OldInit = Pattern->getInClassInitializer(); 2962 if (!OldInit) { 2963 RecordDecl *PatternRD = Pattern->getParent(); 2964 RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext(); 2965 Diag(PointOfInstantiation, 2966 diag::err_default_member_initializer_not_yet_parsed) 2967 << OutermostClass << Pattern; 2968 Diag(Pattern->getEndLoc(), 2969 diag::note_default_member_initializer_not_yet_parsed); 2970 Instantiation->setInvalidDecl(); 2971 return true; 2972 } 2973 2974 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 2975 if (Inst.isInvalid()) 2976 return true; 2977 if (Inst.isAlreadyInstantiating()) { 2978 // Error out if we hit an instantiation cycle for this initializer. 2979 Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle) 2980 << Instantiation; 2981 return true; 2982 } 2983 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(), 2984 "instantiating default member init"); 2985 2986 // Enter the scope of this instantiation. We don't use PushDeclContext because 2987 // we don't have a scope. 2988 ContextRAII SavedContext(*this, Instantiation->getParent()); 2989 EnterExpressionEvaluationContext EvalContext( 2990 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 2991 2992 LocalInstantiationScope Scope(*this, true); 2993 2994 // Instantiate the initializer. 2995 ActOnStartCXXInClassMemberInitializer(); 2996 CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), Qualifiers()); 2997 2998 ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs, 2999 /*CXXDirectInit=*/false); 3000 Expr *Init = NewInit.get(); 3001 assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class")(static_cast <bool> ((!Init || !isa<ParenListExpr>
(Init)) && "call-style init in class") ? void (0) : __assert_fail
("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3001, __extension__ __PRETTY_FUNCTION__)); 3002 ActOnFinishCXXInClassMemberInitializer( 3003 Instantiation, Init ? Init->getBeginLoc() : SourceLocation(), Init); 3004 3005 if (auto *L = getASTMutationListener()) 3006 L->DefaultMemberInitializerInstantiated(Instantiation); 3007 3008 // Return true if the in-class initializer is still missing. 3009 return !Instantiation->getInClassInitializer(); 3010} 3011 3012namespace { 3013 /// A partial specialization whose template arguments have matched 3014 /// a given template-id. 3015 struct PartialSpecMatchResult { 3016 ClassTemplatePartialSpecializationDecl *Partial; 3017 TemplateArgumentList *Args; 3018 }; 3019} 3020 3021bool Sema::usesPartialOrExplicitSpecialization( 3022 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) { 3023 if (ClassTemplateSpec->getTemplateSpecializationKind() == 3024 TSK_ExplicitSpecialization) 3025 return true; 3026 3027 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 3028 ClassTemplateSpec->getSpecializedTemplate() 3029 ->getPartialSpecializations(PartialSpecs); 3030 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) { 3031 TemplateDeductionInfo Info(Loc); 3032 if (!DeduceTemplateArguments(PartialSpecs[I], 3033 ClassTemplateSpec->getTemplateArgs(), Info)) 3034 return true; 3035 } 3036 3037 return false; 3038} 3039 3040/// Get the instantiation pattern to use to instantiate the definition of a 3041/// given ClassTemplateSpecializationDecl (either the pattern of the primary 3042/// template or of a partial specialization). 3043static ActionResult<CXXRecordDecl *> 3044getPatternForClassTemplateSpecialization( 3045 Sema &S, SourceLocation PointOfInstantiation, 3046 ClassTemplateSpecializationDecl *ClassTemplateSpec, 3047 TemplateSpecializationKind TSK) { 3048 Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec); 3049 if (Inst.isInvalid()) 3050 return {/*Invalid=*/true}; 3051 if (Inst.isAlreadyInstantiating()) 3052 return {/*Invalid=*/false}; 3053 3054 llvm::PointerUnion<ClassTemplateDecl *, 3055 ClassTemplatePartialSpecializationDecl *> 3056 Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial(); 3057 if (!Specialized.is<ClassTemplatePartialSpecializationDecl *>()) { 3058 // Find best matching specialization. 3059 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate(); 3060 3061 // C++ [temp.class.spec.match]p1: 3062 // When a class template is used in a context that requires an 3063 // instantiation of the class, it is necessary to determine 3064 // whether the instantiation is to be generated using the primary 3065 // template or one of the partial specializations. This is done by 3066 // matching the template arguments of the class template 3067 // specialization with the template argument lists of the partial 3068 // specializations. 3069 typedef PartialSpecMatchResult MatchResult; 3070 SmallVector<MatchResult, 4> Matched; 3071 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 3072 Template->getPartialSpecializations(PartialSpecs); 3073 TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation); 3074 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) { 3075 ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I]; 3076 TemplateDeductionInfo Info(FailedCandidates.getLocation()); 3077 if (Sema::TemplateDeductionResult Result = S.DeduceTemplateArguments( 3078 Partial, ClassTemplateSpec->getTemplateArgs(), Info)) { 3079 // Store the failed-deduction information for use in diagnostics, later. 3080 // TODO: Actually use the failed-deduction info? 3081 FailedCandidates.addCandidate().set( 3082 DeclAccessPair::make(Template, AS_public), Partial, 3083 MakeDeductionFailureInfo(S.Context, Result, Info)); 3084 (void)Result; 3085 } else { 3086 Matched.push_back(PartialSpecMatchResult()); 3087 Matched.back().Partial = Partial; 3088 Matched.back().Args = Info.take(); 3089 } 3090 } 3091 3092 // If we're dealing with a member template where the template parameters 3093 // have been instantiated, this provides the original template parameters 3094 // from which the member template's parameters were instantiated. 3095 3096 if (Matched.size() >= 1) { 3097 SmallVectorImpl<MatchResult>::iterator Best = Matched.begin(); 3098 if (Matched.size() == 1) { 3099 // -- If exactly one matching specialization is found, the 3100 // instantiation is generated from that specialization. 3101 // We don't need to do anything for this. 3102 } else { 3103 // -- If more than one matching specialization is found, the 3104 // partial order rules (14.5.4.2) are used to determine 3105 // whether one of the specializations is more specialized 3106 // than the others. If none of the specializations is more 3107 // specialized than all of the other matching 3108 // specializations, then the use of the class template is 3109 // ambiguous and the program is ill-formed. 3110 for (SmallVectorImpl<MatchResult>::iterator P = Best + 1, 3111 PEnd = Matched.end(); 3112 P != PEnd; ++P) { 3113 if (S.getMoreSpecializedPartialSpecialization( 3114 P->Partial, Best->Partial, PointOfInstantiation) == 3115 P->Partial) 3116 Best = P; 3117 } 3118 3119 // Determine if the best partial specialization is more specialized than 3120 // the others. 3121 bool Ambiguous = false; 3122 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(), 3123 PEnd = Matched.end(); 3124 P != PEnd; ++P) { 3125 if (P != Best && S.getMoreSpecializedPartialSpecialization( 3126 P->Partial, Best->Partial, 3127 PointOfInstantiation) != Best->Partial) { 3128 Ambiguous = true; 3129 break; 3130 } 3131 } 3132 3133 if (Ambiguous) { 3134 // Partial ordering did not produce a clear winner. Complain. 3135 Inst.Clear(); 3136 ClassTemplateSpec->setInvalidDecl(); 3137 S.Diag(PointOfInstantiation, 3138 diag::err_partial_spec_ordering_ambiguous) 3139 << ClassTemplateSpec; 3140 3141 // Print the matching partial specializations. 3142 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(), 3143 PEnd = Matched.end(); 3144 P != PEnd; ++P) 3145 S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match) 3146 << S.getTemplateArgumentBindingsText( 3147 P->Partial->getTemplateParameters(), *P->Args); 3148 3149 return {/*Invalid=*/true}; 3150 } 3151 } 3152 3153 ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args); 3154 } else { 3155 // -- If no matches are found, the instantiation is generated 3156 // from the primary template. 3157 } 3158 } 3159 3160 CXXRecordDecl *Pattern = nullptr; 3161 Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial(); 3162 if (auto *PartialSpec = 3163 Specialized.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) { 3164 // Instantiate using the best class template partial specialization. 3165 while (PartialSpec->getInstantiatedFromMember()) { 3166 // If we've found an explicit specialization of this class template, 3167 // stop here and use that as the pattern. 3168 if (PartialSpec->isMemberSpecialization()) 3169 break; 3170 3171 PartialSpec = PartialSpec->getInstantiatedFromMember(); 3172 } 3173 Pattern = PartialSpec; 3174 } else { 3175 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate(); 3176 while (Template->getInstantiatedFromMemberTemplate()) { 3177 // If we've found an explicit specialization of this class template, 3178 // stop here and use that as the pattern. 3179 if (Template->isMemberSpecialization()) 3180 break; 3181 3182 Template = Template->getInstantiatedFromMemberTemplate(); 3183 } 3184 Pattern = Template->getTemplatedDecl(); 3185 } 3186 3187 return Pattern; 3188} 3189 3190bool Sema::InstantiateClassTemplateSpecialization( 3191 SourceLocation PointOfInstantiation, 3192 ClassTemplateSpecializationDecl *ClassTemplateSpec, 3193 TemplateSpecializationKind TSK, bool Complain) { 3194 // Perform the actual instantiation on the canonical declaration. 3195 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>( 3196 ClassTemplateSpec->getCanonicalDecl()); 3197 if (ClassTemplateSpec->isInvalidDecl()) 3198 return true; 3199 3200 ActionResult<CXXRecordDecl *> Pattern = 3201 getPatternForClassTemplateSpecialization(*this, PointOfInstantiation, 3202 ClassTemplateSpec, TSK); 3203 if (!Pattern.isUsable()) 3204 return Pattern.isInvalid(); 3205 3206 return InstantiateClass( 3207 PointOfInstantiation, ClassTemplateSpec, Pattern.get(), 3208 getTemplateInstantiationArgs(ClassTemplateSpec), TSK, Complain); 3209} 3210 3211/// Instantiates the definitions of all of the member 3212/// of the given class, which is an instantiation of a class template 3213/// or a member class of a template. 3214void 3215Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation, 3216 CXXRecordDecl *Instantiation, 3217 const MultiLevelTemplateArgumentList &TemplateArgs, 3218 TemplateSpecializationKind TSK) { 3219 // FIXME: We need to notify the ASTMutationListener that we did all of these 3220 // things, in case we have an explicit instantiation definition in a PCM, a 3221 // module, or preamble, and the declaration is in an imported AST. 3222 assert((static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3226, __extension__ __PRETTY_FUNCTION__))

Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDefinition

→

←

Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDeclaration

→

←

Assuming 'TSK' is equal to TSK_ImplicitInstantiation

→

←

'?' condition is true

→

3223 (TSK == TSK_ExplicitInstantiationDefinition ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3226, __extension__ __PRETTY_FUNCTION__)) 3224 TSK == TSK_ExplicitInstantiationDeclaration ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3226, __extension__ __PRETTY_FUNCTION__)) 3225 (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3226, __extension__ __PRETTY_FUNCTION__)) 3226 "Unexpected template specialization kind!")(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3226, __extension__ __PRETTY_FUNCTION__)); 3227 for (auto *D : Instantiation->decls()) { 3228 bool SuppressNew = false; 3229 if (auto *Function

5.1	'Function' is null

5.1	'Function' is null

= dyn_cast<FunctionDecl>(D)) {

←

Assuming 'D' is not a 'FunctionDecl'

→

←

Taking false branch

→

3230 if (FunctionDecl *Pattern = 3231 Function->getInstantiatedFromMemberFunction()) { 3232 3233 if (Function->hasAttr<ExcludeFromExplicitInstantiationAttr>()) 3234 continue; 3235 3236 MemberSpecializationInfo *MSInfo = 3237 Function->getMemberSpecializationInfo(); 3238 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3238, __extension__ __PRETTY_FUNCTION__)); 3239 if (MSInfo->getTemplateSpecializationKind() 3240 == TSK_ExplicitSpecialization) 3241 continue; 3242 3243 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 3244 Function, 3245 MSInfo->getTemplateSpecializationKind(), 3246 MSInfo->getPointOfInstantiation(), 3247 SuppressNew) || 3248 SuppressNew) 3249 continue; 3250 3251 // C++11 [temp.explicit]p8: 3252 // An explicit instantiation definition that names a class template 3253 // specialization explicitly instantiates the class template 3254 // specialization and is only an explicit instantiation definition 3255 // of members whose definition is visible at the point of 3256 // instantiation. 3257 if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined()) 3258 continue; 3259 3260 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation); 3261 3262 if (Function->isDefined()) { 3263 // Let the ASTConsumer know that this function has been explicitly 3264 // instantiated now, and its linkage might have changed. 3265 Consumer.HandleTopLevelDecl(DeclGroupRef(Function)); 3266 } else if (TSK == TSK_ExplicitInstantiationDefinition) { 3267 InstantiateFunctionDefinition(PointOfInstantiation, Function); 3268 } else if (TSK == TSK_ImplicitInstantiation) { 3269 PendingLocalImplicitInstantiations.push_back( 3270 std::make_pair(Function, PointOfInstantiation)); 3271 } 3272 } 3273 } else if (auto *Var

7.1	'Var' is null

7.1	'Var' is null

= dyn_cast<VarDecl>(D)) {

←

Assuming 'D' is not a 'VarDecl'

→

←

Taking false branch

→

3274 if (isa<VarTemplateSpecializationDecl>(Var)) 3275 continue; 3276 3277 if (Var->isStaticDataMember()) { 3278 if (Var->hasAttr<ExcludeFromExplicitInstantiationAttr>()) 3279 continue; 3280 3281 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 3282 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3282, __extension__ __PRETTY_FUNCTION__)); 3283 if (MSInfo->getTemplateSpecializationKind() 3284 == TSK_ExplicitSpecialization) 3285 continue; 3286 3287 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK, 3288 Var, 3289 MSInfo->getTemplateSpecializationKind(), 3290 MSInfo->getPointOfInstantiation(), 3291 SuppressNew) || 3292 SuppressNew) 3293 continue; 3294 3295 if (TSK == TSK_ExplicitInstantiationDefinition) { 3296 // C++0x [temp.explicit]p8: 3297 // An explicit instantiation definition that names a class template 3298 // specialization explicitly instantiates the class template 3299 // specialization and is only an explicit instantiation definition 3300 // of members whose definition is visible at the point of 3301 // instantiation. 3302 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition()) 3303 continue; 3304 3305 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation); 3306 InstantiateVariableDefinition(PointOfInstantiation, Var); 3307 } else { 3308 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation); 3309 } 3310 } 3311 } else if (auto *Record

9.1	'Record' is non-null

9.1	'Record' is non-null

= dyn_cast<CXXRecordDecl>(D)) {

←

Assuming 'D' is a 'CXXRecordDecl'

→

←

Taking true branch

→

3312 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())

←

Taking false branch

→

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

←

Assuming the condition is false

→

←

Taking false branch

→

3321 Record->isLambda()) 3322 continue; 3323 3324 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo(); 3325 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3325, __extension__ __PRETTY_FUNCTION__));

←

Assuming 'MSInfo' is non-null

→

←

'?' condition is true

→

3326 3327 if (MSInfo->getTemplateSpecializationKind()

←

Assuming the condition is false

→

←

Taking false branch

→

3328 == TSK_ExplicitSpecialization) 3329 continue; 3330 3331 if (Context.getTargetInfo().getTriple().isOSWindows() && 3332 TSK == TSK_ExplicitInstantiationDeclaration) { 3333 // On Windows, explicit instantiation decl of the outer class doesn't 3334 // affect the inner class. Typically extern template declarations are 3335 // used in combination with dll import/export annotations, but those 3336 // are not propagated from the outer class templates to inner classes. 3337 // Therefore, do not instantiate inner classes on this platform, so 3338 // that users don't end up with undefined symbols during linking. 3339 continue; 3340 } 3341 3342 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,

←

Assuming the condition is false

→

←

Assuming the condition is false

→

←

Taking false branch

→

3343 Record, 3344 MSInfo->getTemplateSpecializationKind(), 3345 MSInfo->getPointOfInstantiation(), 3346 SuppressNew) || 3347 SuppressNew) 3348 continue; 3349 3350 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 3351 assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3351, __extension__ __PRETTY_FUNCTION__));

←

Assuming 'Pattern' is non-null

→

←

'?' condition is true

→

3352 3353 if (!Record->getDefinition()) {

←

Assuming the condition is true

→

←

Taking true branch

→

3354 if (!Pattern->getDefinition()) {

←

Assuming the condition is false

→

←

Taking false branch

→

3355 // C++0x [temp.explicit]p8: 3356 // An explicit instantiation definition that names a class template 3357 // specialization explicitly instantiates the class template 3358 // specialization and is only an explicit instantiation definition 3359 // of members whose definition is visible at the point of 3360 // instantiation. 3361 if (TSK == TSK_ExplicitInstantiationDeclaration) { 3362 MSInfo->setTemplateSpecializationKind(TSK); 3363 MSInfo->setPointOfInstantiation(PointOfInstantiation); 3364 } 3365 3366 continue; 3367 } 3368 3369 InstantiateClass(PointOfInstantiation, Record, Pattern,

←

Calling 'Sema::InstantiateClass'

→

3370 TemplateArgs, 3371 TSK); 3372 } else { 3373 if (TSK == TSK_ExplicitInstantiationDefinition && 3374 Record->getTemplateSpecializationKind() == 3375 TSK_ExplicitInstantiationDeclaration) { 3376 Record->setTemplateSpecializationKind(TSK); 3377 MarkVTableUsed(PointOfInstantiation, Record, true); 3378 } 3379 } 3380 3381 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition()); 3382 if (Pattern) 3383 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs, 3384 TSK); 3385 } else if (auto *Enum = dyn_cast<EnumDecl>(D)) { 3386 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo(); 3387 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3387, __extension__ __PRETTY_FUNCTION__)); 3388 3389 if (MSInfo->getTemplateSpecializationKind() 3390 == TSK_ExplicitSpecialization) 3391 continue; 3392 3393 if (CheckSpecializationInstantiationRedecl( 3394 PointOfInstantiation, TSK, Enum, 3395 MSInfo->getTemplateSpecializationKind(), 3396 MSInfo->getPointOfInstantiation(), SuppressNew) || 3397 SuppressNew) 3398 continue; 3399 3400 if (Enum->getDefinition()) 3401 continue; 3402 3403 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern(); 3404 assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3404, __extension__ __PRETTY_FUNCTION__)); 3405 3406 if (TSK == TSK_ExplicitInstantiationDefinition) { 3407 if (!Pattern->getDefinition()) 3408 continue; 3409 3410 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK); 3411 } else { 3412 MSInfo->setTemplateSpecializationKind(TSK); 3413 MSInfo->setPointOfInstantiation(PointOfInstantiation); 3414 } 3415 } else if (auto *Field = dyn_cast<FieldDecl>(D)) { 3416 // No need to instantiate in-class initializers during explicit 3417 // instantiation. 3418 if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) { 3419 CXXRecordDecl *ClassPattern = 3420 Instantiation->getTemplateInstantiationPattern(); 3421 DeclContext::lookup_result Lookup = 3422 ClassPattern->lookup(Field->getDeclName()); 3423 FieldDecl *Pattern = Lookup.find_first<FieldDecl>(); 3424 assert(Pattern)(static_cast <bool> (Pattern) ? void (0) : __assert_fail
("Pattern", "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3424, __extension__ __PRETTY_FUNCTION__)); 3425 InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern, 3426 TemplateArgs); 3427 } 3428 } 3429 } 3430} 3431 3432/// Instantiate the definitions of all of the members of the 3433/// given class template specialization, which was named as part of an 3434/// explicit instantiation. 3435void 3436Sema::InstantiateClassTemplateSpecializationMembers( 3437 SourceLocation PointOfInstantiation, 3438 ClassTemplateSpecializationDecl *ClassTemplateSpec, 3439 TemplateSpecializationKind TSK) { 3440 // C++0x [temp.explicit]p7: 3441 // An explicit instantiation that names a class template 3442 // specialization is an explicit instantion of the same kind 3443 // (declaration or definition) of each of its members (not 3444 // including members inherited from base classes) that has not 3445 // been previously explicitly specialized in the translation unit 3446 // containing the explicit instantiation, except as described 3447 // below. 3448 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec, 3449 getTemplateInstantiationArgs(ClassTemplateSpec), 3450 TSK); 3451} 3452 3453StmtResult 3454Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) { 3455 if (!S) 3456 return S; 3457 3458 TemplateInstantiator Instantiator(*this, TemplateArgs, 3459 SourceLocation(), 3460 DeclarationName()); 3461 return Instantiator.TransformStmt(S); 3462} 3463 3464bool Sema::SubstTemplateArguments( 3465 ArrayRef<TemplateArgumentLoc> Args, 3466 const MultiLevelTemplateArgumentList &TemplateArgs, 3467 TemplateArgumentListInfo &Out) { 3468 TemplateInstantiator Instantiator(*this, TemplateArgs, 3469 SourceLocation(), 3470 DeclarationName()); 3471 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), 3472 Out); 3473} 3474 3475ExprResult 3476Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) { 3477 if (!E) 3478 return E; 3479 3480 TemplateInstantiator Instantiator(*this, TemplateArgs, 3481 SourceLocation(), 3482 DeclarationName()); 3483 return Instantiator.TransformExpr(E); 3484} 3485 3486ExprResult Sema::SubstInitializer(Expr *Init, 3487 const MultiLevelTemplateArgumentList &TemplateArgs, 3488 bool CXXDirectInit) { 3489 TemplateInstantiator Instantiator(*this, TemplateArgs, 3490 SourceLocation(), 3491 DeclarationName()); 3492 return Instantiator.TransformInitializer(Init, CXXDirectInit); 3493} 3494 3495bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall, 3496 const MultiLevelTemplateArgumentList &TemplateArgs, 3497 SmallVectorImpl<Expr *> &Outputs) { 3498 if (Exprs.empty()) 3499 return false; 3500 3501 TemplateInstantiator Instantiator(*this, TemplateArgs, 3502 SourceLocation(), 3503 DeclarationName()); 3504 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(), 3505 IsCall, Outputs); 3506} 3507 3508NestedNameSpecifierLoc 3509Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 3510 const MultiLevelTemplateArgumentList &TemplateArgs) { 3511 if (!NNS) 3512 return NestedNameSpecifierLoc(); 3513 3514 TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(), 3515 DeclarationName()); 3516 return Instantiator.TransformNestedNameSpecifierLoc(NNS); 3517} 3518 3519/// Do template substitution on declaration name info. 3520DeclarationNameInfo 3521Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 3522 const MultiLevelTemplateArgumentList &TemplateArgs) { 3523 TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(), 3524 NameInfo.getName()); 3525 return Instantiator.TransformDeclarationNameInfo(NameInfo); 3526} 3527 3528TemplateName 3529Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, 3530 TemplateName Name, SourceLocation Loc, 3531 const MultiLevelTemplateArgumentList &TemplateArgs) { 3532 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 3533 DeclarationName()); 3534 CXXScopeSpec SS; 3535 SS.Adopt(QualifierLoc); 3536 return Instantiator.TransformTemplateName(SS, Name, Loc); 3537} 3538 3539bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, 3540 TemplateArgumentListInfo &Result, 3541 const MultiLevelTemplateArgumentList &TemplateArgs) { 3542 TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(), 3543 DeclarationName()); 3544 3545 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result); 3546} 3547 3548static const Decl *getCanonicalParmVarDecl(const Decl *D) { 3549 // When storing ParmVarDecls in the local instantiation scope, we always 3550 // want to use the ParmVarDecl from the canonical function declaration, 3551 // since the map is then valid for any redeclaration or definition of that 3552 // function. 3553 if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) { 3554 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) { 3555 unsigned i = PV->getFunctionScopeIndex(); 3556 // This parameter might be from a freestanding function type within the 3557 // function and isn't necessarily referring to one of FD's parameters. 3558 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV) 3559 return FD->getCanonicalDecl()->getParamDecl(i); 3560 } 3561 } 3562 return D; 3563} 3564 3565 3566llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> * 3567LocalInstantiationScope::findInstantiationOf(const Decl *D) { 3568 D = getCanonicalParmVarDecl(D); 3569 for (LocalInstantiationScope *Current = this; Current; 3570 Current = Current->Outer) { 3571 3572 // Check if we found something within this scope. 3573 const Decl *CheckD = D; 3574 do { 3575 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD); 3576 if (Found != Current->LocalDecls.end()) 3577 return &Found->second; 3578 3579 // If this is a tag declaration, it's possible that we need to look for 3580 // a previous declaration. 3581 if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD)) 3582 CheckD = Tag->getPreviousDecl(); 3583 else 3584 CheckD = nullptr; 3585 } while (CheckD); 3586 3587 // If we aren't combined with our outer scope, we're done. 3588 if (!Current->CombineWithOuterScope) 3589 break; 3590 } 3591 3592 // If we're performing a partial substitution during template argument 3593 // deduction, we may not have values for template parameters yet. 3594 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) || 3595 isa<TemplateTemplateParmDecl>(D)) 3596 return nullptr; 3597 3598 // Local types referenced prior to definition may require instantiation. 3599 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 3600 if (RD->isLocalClass()) 3601 return nullptr; 3602 3603 // Enumeration types referenced prior to definition may appear as a result of 3604 // error recovery. 3605 if (isa<EnumDecl>(D)) 3606 return nullptr; 3607 3608 // Materialized typedefs/type alias for implicit deduction guides may require 3609 // instantiation. 3610 if (isa<TypedefNameDecl>(D) && 3611 isa<CXXDeductionGuideDecl>(D->getDeclContext())) 3612 return nullptr; 3613 3614 // If we didn't find the decl, then we either have a sema bug, or we have a 3615 // forward reference to a label declaration. Return null to indicate that 3616 // we have an uninstantiated label. 3617 assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope")(static_cast <bool> (isa<LabelDecl>(D) &&
"declaration not instantiated in this scope") ? void (0) : __assert_fail
("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3617, __extension__ __PRETTY_FUNCTION__)); 3618 return nullptr; 3619} 3620 3621void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) { 3622 D = getCanonicalParmVarDecl(D); 3623 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D]; 3624 if (Stored.isNull()) { 3625#ifndef NDEBUG 3626 // It should not be present in any surrounding scope either. 3627 LocalInstantiationScope *Current = this; 3628 while (Current->CombineWithOuterScope && Current->Outer) { 3629 Current = Current->Outer; 3630 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3631, __extension__ __PRETTY_FUNCTION__)) 3631 "Instantiated local in inner and outer scopes")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3631, __extension__ __PRETTY_FUNCTION__)); 3632 } 3633#endif 3634 Stored = Inst; 3635 } else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) { 3636 Pack->push_back(cast<VarDecl>(Inst)); 3637 } else { 3638 assert(Stored.get<Decl *>() == Inst && "Already instantiated this local")(static_cast <bool> (Stored.get<Decl *>() == Inst
&& "Already instantiated this local") ? void (0) : __assert_fail
("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3638, __extension__ __PRETTY_FUNCTION__)); 3639 } 3640} 3641 3642void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D, 3643 VarDecl *Inst) { 3644 D = getCanonicalParmVarDecl(D); 3645 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>(); 3646 Pack->push_back(Inst); 3647} 3648 3649void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) { 3650#ifndef NDEBUG 3651 // This should be the first time we've been told about this decl. 3652 for (LocalInstantiationScope *Current = this; 3653 Current && Current->CombineWithOuterScope; Current = Current->Outer) 3654 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3655, __extension__ __PRETTY_FUNCTION__)) 3655 "Creating local pack after instantiation of local")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3655, __extension__ __PRETTY_FUNCTION__)); 3656#endif 3657 3658 D = getCanonicalParmVarDecl(D); 3659 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D]; 3660 DeclArgumentPack *Pack = new DeclArgumentPack; 3661 Stored = Pack; 3662 ArgumentPacks.push_back(Pack); 3663} 3664 3665bool LocalInstantiationScope::isLocalPackExpansion(const Decl *D) { 3666 for (DeclArgumentPack *Pack : ArgumentPacks) 3667 if (std::find(Pack->begin(), Pack->end(), D) != Pack->end()) 3668 return true; 3669 return false; 3670} 3671 3672void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack, 3673 const TemplateArgument *ExplicitArgs, 3674 unsigned NumExplicitArgs) { 3675 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
== Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3676, __extension__ __PRETTY_FUNCTION__)) 3676 "Already have a partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
== Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3676, __extension__ __PRETTY_FUNCTION__)); 3677 assert((!PartiallySubstitutedPack(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3679, __extension__ __PRETTY_FUNCTION__)) 3678 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3679, __extension__ __PRETTY_FUNCTION__)) 3679 "Wrong number of arguments in partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3679, __extension__ __PRETTY_FUNCTION__)); 3680 PartiallySubstitutedPack = Pack; 3681 ArgsInPartiallySubstitutedPack = ExplicitArgs; 3682 NumArgsInPartiallySubstitutedPack = NumExplicitArgs; 3683} 3684 3685NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack( 3686 const TemplateArgument **ExplicitArgs, 3687 unsigned *NumExplicitArgs) const { 3688 if (ExplicitArgs) 3689 *ExplicitArgs = nullptr; 3690 if (NumExplicitArgs) 3691 *NumExplicitArgs = 0; 3692 3693 for (const LocalInstantiationScope *Current = this; Current; 3694 Current = Current->Outer) { 3695 if (Current->PartiallySubstitutedPack) { 3696 if (ExplicitArgs) 3697 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack; 3698 if (NumExplicitArgs) 3699 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack; 3700 3701 return Current->PartiallySubstitutedPack; 3702 } 3703 3704 if (!Current->CombineWithOuterScope) 3705 break; 3706 } 3707 3708 return nullptr; 3709}

←

/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h

1	//===--- Sema.h - Semantic Analysis & AST Building --------------- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file defines the Sema class, which performs semantic analysis and
10	// builds ASTs.
11	//
12	//===----------------------------------------------------------------------===//
13
14	#ifndef LLVM_CLANG_SEMA_SEMA_H
15	#define LLVM_CLANG_SEMA_SEMA_H
16
17	#include "clang/AST/ASTConcept.h"
18	#include "clang/AST/ASTFwd.h"
19	#include "clang/AST/Attr.h"
20	#include "clang/AST/Availability.h"
21	#include "clang/AST/ComparisonCategories.h"
22	#include "clang/AST/DeclTemplate.h"
23	#include "clang/AST/DeclarationName.h"
24	#include "clang/AST/Expr.h"
25	#include "clang/AST/ExprCXX.h"
26	#include "clang/AST/ExprConcepts.h"
27	#include "clang/AST/ExprObjC.h"
28	#include "clang/AST/ExprOpenMP.h"
29	#include "clang/AST/ExternalASTSource.h"
30	#include "clang/AST/LocInfoType.h"
31	#include "clang/AST/MangleNumberingContext.h"
32	#include "clang/AST/NSAPI.h"
33	#include "clang/AST/PrettyPrinter.h"
34	#include "clang/AST/StmtCXX.h"
35	#include "clang/AST/TypeLoc.h"
36	#include "clang/AST/TypeOrdering.h"
37	#include "clang/Basic/BitmaskEnum.h"
38	#include "clang/Basic/ExpressionTraits.h"
39	#include "clang/Basic/Module.h"
40	#include "clang/Basic/OpenCLOptions.h"
41	#include "clang/Basic/OpenMPKinds.h"
42	#include "clang/Basic/PragmaKinds.h"
43	#include "clang/Basic/Specifiers.h"
44	#include "clang/Basic/TemplateKinds.h"
45	#include "clang/Basic/TypeTraits.h"
46	#include "clang/Sema/AnalysisBasedWarnings.h"
47	#include "clang/Sema/CleanupInfo.h"
48	#include "clang/Sema/DeclSpec.h"
49	#include "clang/Sema/ExternalSemaSource.h"
50	#include "clang/Sema/IdentifierResolver.h"
51	#include "clang/Sema/ObjCMethodList.h"
52	#include "clang/Sema/Ownership.h"
53	#include "clang/Sema/Scope.h"
54	#include "clang/Sema/SemaConcept.h"
55	#include "clang/Sema/TypoCorrection.h"
56	#include "clang/Sema/Weak.h"
57	#include "llvm/ADT/ArrayRef.h"
58	#include "llvm/ADT/Optional.h"
59	#include "llvm/ADT/SetVector.h"
60	#include "llvm/ADT/SmallBitVector.h"
61	#include "llvm/ADT/SmallPtrSet.h"
62	#include "llvm/ADT/SmallSet.h"
63	#include "llvm/ADT/SmallVector.h"
64	#include "llvm/ADT/TinyPtrVector.h"
65	#include "llvm/Frontend/OpenMP/OMPConstants.h"
66	#include <deque>
67	#include <memory>
68	#include <string>
69	#include <tuple>
70	#include <vector>
71
72	namespace llvm {
73	class APSInt;
74	template <typename ValueT> struct DenseMapInfo;
75	template <typename ValueT, typename ValueInfoT> class DenseSet;
76	class SmallBitVector;
77	struct InlineAsmIdentifierInfo;
78	}
79
80	namespace clang {
81	class ADLResult;
82	class ASTConsumer;
83	class ASTContext;
84	class ASTMutationListener;
85	class ASTReader;
86	class ASTWriter;
87	class ArrayType;
88	class ParsedAttr;
89	class BindingDecl;
90	class BlockDecl;
91	class CapturedDecl;
92	class CXXBasePath;
93	class CXXBasePaths;
94	class CXXBindTemporaryExpr;
95	typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
96	class CXXConstructorDecl;
97	class CXXConversionDecl;
98	class CXXDeleteExpr;
99	class CXXDestructorDecl;
100	class CXXFieldCollector;
101	class CXXMemberCallExpr;
102	class CXXMethodDecl;
103	class CXXScopeSpec;
104	class CXXTemporary;
105	class CXXTryStmt;
106	class CallExpr;
107	class ClassTemplateDecl;
108	class ClassTemplatePartialSpecializationDecl;
109	class ClassTemplateSpecializationDecl;
110	class VarTemplatePartialSpecializationDecl;
111	class CodeCompleteConsumer;
112	class CodeCompletionAllocator;
113	class CodeCompletionTUInfo;
114	class CodeCompletionResult;
115	class CoroutineBodyStmt;
116	class Decl;
117	class DeclAccessPair;
118	class DeclContext;
119	class DeclRefExpr;
120	class DeclaratorDecl;
121	class DeducedTemplateArgument;
122	class DependentDiagnostic;
123	class DesignatedInitExpr;
124	class Designation;
125	class EnableIfAttr;
126	class EnumConstantDecl;
127	class Expr;
128	class ExtVectorType;
129	class FormatAttr;
130	class FriendDecl;
131	class FunctionDecl;
132	class FunctionProtoType;
133	class FunctionTemplateDecl;
134	class ImplicitConversionSequence;
135	typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
136	class InitListExpr;
137	class InitializationKind;
138	class InitializationSequence;
139	class InitializedEntity;
140	class IntegerLiteral;
141	class LabelStmt;
142	class LambdaExpr;
143	class LangOptions;
144	class LocalInstantiationScope;
145	class LookupResult;
146	class MacroInfo;
147	typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
148	class ModuleLoader;
149	class MultiLevelTemplateArgumentList;
150	class NamedDecl;
151	class ObjCCategoryDecl;
152	class ObjCCategoryImplDecl;
153	class ObjCCompatibleAliasDecl;
154	class ObjCContainerDecl;
155	class ObjCImplDecl;
156	class ObjCImplementationDecl;
157	class ObjCInterfaceDecl;
158	class ObjCIvarDecl;
159	template <class T> class ObjCList;
160	class ObjCMessageExpr;
161	class ObjCMethodDecl;
162	class ObjCPropertyDecl;
163	class ObjCProtocolDecl;
164	class OMPThreadPrivateDecl;
165	class OMPRequiresDecl;
166	class OMPDeclareReductionDecl;
167	class OMPDeclareSimdDecl;
168	class OMPClause;
169	struct OMPVarListLocTy;
170	struct OverloadCandidate;
171	enum class OverloadCandidateParamOrder : char;
172	enum OverloadCandidateRewriteKind : unsigned;
173	class OverloadCandidateSet;
174	class OverloadExpr;
175	class ParenListExpr;
176	class ParmVarDecl;
177	class Preprocessor;
178	class PseudoDestructorTypeStorage;
179	class PseudoObjectExpr;
180	class QualType;
181	class StandardConversionSequence;
182	class Stmt;
183	class StringLiteral;
184	class SwitchStmt;
185	class TemplateArgument;
186	class TemplateArgumentList;
187	class TemplateArgumentLoc;
188	class TemplateDecl;
189	class TemplateInstantiationCallback;
190	class TemplateParameterList;
191	class TemplatePartialOrderingContext;
192	class TemplateTemplateParmDecl;
193	class Token;
194	class TypeAliasDecl;
195	class TypedefDecl;
196	class TypedefNameDecl;
197	class TypeLoc;
198	class TypoCorrectionConsumer;
199	class UnqualifiedId;
200	class UnresolvedLookupExpr;
201	class UnresolvedMemberExpr;
202	class UnresolvedSetImpl;
203	class UnresolvedSetIterator;
204	class UsingDecl;
205	class UsingShadowDecl;
206	class ValueDecl;
207	class VarDecl;
208	class VarTemplateSpecializationDecl;
209	class VisibilityAttr;
210	class VisibleDeclConsumer;
211	class IndirectFieldDecl;
212	struct DeductionFailureInfo;
213	class TemplateSpecCandidateSet;
214
215	namespace sema {
216	class AccessedEntity;
217	class BlockScopeInfo;
218	class Capture;
219	class CapturedRegionScopeInfo;
220	class CapturingScopeInfo;
221	class CompoundScopeInfo;
222	class DelayedDiagnostic;
223	class DelayedDiagnosticPool;
224	class FunctionScopeInfo;
225	class LambdaScopeInfo;
226	class PossiblyUnreachableDiag;
227	class SemaPPCallbacks;
228	class TemplateDeductionInfo;
229	}
230
231	namespace threadSafety {
232	class BeforeSet;
233	void threadSafetyCleanup(BeforeSet* Cache);
234	}
235
236	// FIXME: No way to easily map from TemplateTypeParmTypes to
237	// TemplateTypeParmDecls, so we have this horrible PointerUnion.
238	typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType, NamedDecl>,
239	SourceLocation> UnexpandedParameterPack;
240
241	/// Describes whether we've seen any nullability information for the given
242	/// file.
243	struct FileNullability {
244	/// The first pointer declarator (of any pointer kind) in the file that does
245	/// not have a corresponding nullability annotation.
246	SourceLocation PointerLoc;
247
248	/// The end location for the first pointer declarator in the file. Used for
249	/// placing fix-its.
250	SourceLocation PointerEndLoc;
251
252	/// Which kind of pointer declarator we saw.
253	uint8_t PointerKind;
254
255	/// Whether we saw any type nullability annotations in the given file.
256	bool SawTypeNullability = false;
257	};
258
259	/// A mapping from file IDs to a record of whether we've seen nullability
260	/// information in that file.
261	class FileNullabilityMap {
262	/// A mapping from file IDs to the nullability information for each file ID.
263	llvm::DenseMap<FileID, FileNullability> Map;
264
265	/// A single-element cache based on the file ID.
266	struct {
267	FileID File;
268	FileNullability Nullability;
269	} Cache;
270
271	public:
272	FileNullability &operator[](FileID file) {
273	// Check the single-element cache.
274	if (file == Cache.File)
275	return Cache.Nullability;
276
277	// It's not in the single-element cache; flush the cache if we have one.
278	if (!Cache.File.isInvalid()) {
279	Map[Cache.File] = Cache.Nullability;
280	}
281
282	// Pull this entry into the cache.
283	Cache.File = file;
284	Cache.Nullability = Map[file];
285	return Cache.Nullability;
286	}
287	};
288
289	/// Tracks expected type during expression parsing, for use in code completion.
290	/// The type is tied to a particular token, all functions that update or consume
291	/// the type take a start location of the token they are looking at as a
292	/// parameter. This avoids updating the type on hot paths in the parser.
293	class PreferredTypeBuilder {
294	public:
295	PreferredTypeBuilder(bool Enabled) : Enabled(Enabled) {}
296
297	void enterCondition(Sema &S, SourceLocation Tok);
298	void enterReturn(Sema &S, SourceLocation Tok);
299	void enterVariableInit(SourceLocation Tok, Decl *D);
300	/// Handles e.g. BaseType{ .D = Tok...
301	void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType,
302	const Designation &D);
303	/// Computing a type for the function argument may require running
304	/// overloading, so we postpone its computation until it is actually needed.
305	///
306	/// Clients should be very careful when using this funciton, as it stores a
307	/// function_ref, clients should make sure all calls to get() with the same
308	/// location happen while function_ref is alive.
309	///
310	/// The callback should also emit signature help as a side-effect, but only
311	/// if the completion point has been reached.
312	void enterFunctionArgument(SourceLocation Tok,
313	llvm::function_ref<QualType()> ComputeType);
314
315	void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc);
316	void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind,
317	SourceLocation OpLoc);
318	void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);
319	void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);
320	void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);
321	/// Handles all type casts, including C-style cast, C++ casts, etc.
322	void enterTypeCast(SourceLocation Tok, QualType CastType);
323
324	/// Get the expected type associated with this location, if any.
325	///
326	/// If the location is a function argument, determining the expected type
327	/// involves considering all function overloads and the arguments so far.
328	/// In this case, signature help for these function overloads will be reported
329	/// as a side-effect (only if the completion point has been reached).
330	QualType get(SourceLocation Tok) const {
331	if (!Enabled \|\| Tok != ExpectedLoc)
332	return QualType();
333	if (!Type.isNull())
334	return Type;
335	if (ComputeType)
336	return ComputeType();
337	return QualType();
338	}
339
340	private:
341	bool Enabled;
342	/// Start position of a token for which we store expected type.
343	SourceLocation ExpectedLoc;
344	/// Expected type for a token starting at ExpectedLoc.
345	QualType Type;
346	/// A function to compute expected type at ExpectedLoc. It is only considered
347	/// if Type is null.
348	llvm::function_ref<QualType()> ComputeType;
349	};
350
351	/// Sema - This implements semantic analysis and AST building for C.
352	class Sema final {
353	Sema(const Sema &) = delete;
354	void operator=(const Sema &) = delete;
355
356	///Source of additional semantic information.
357	ExternalSemaSource *ExternalSource;
358
359	///Whether Sema has generated a multiplexer and has to delete it.
360	bool isMultiplexExternalSource;
361
362	static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
363
364	bool isVisibleSlow(const NamedDecl *D);
365
366	/// Determine whether two declarations should be linked together, given that
367	/// the old declaration might not be visible and the new declaration might
368	/// not have external linkage.
369	bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
370	const NamedDecl *New) {
371	if (isVisible(Old))
372	return true;
373	// See comment in below overload for why it's safe to compute the linkage
374	// of the new declaration here.
375	if (New->isExternallyDeclarable()) {
376	assert(Old->isExternallyDeclarable() &&(static_cast <bool> (Old->isExternallyDeclarable() && "should not have found a non-externally-declarable previous decl" ) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\"" , "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 377, __extension__ __PRETTY_FUNCTION__))
377	"should not have found a non-externally-declarable previous decl")(static_cast <bool> (Old->isExternallyDeclarable() && "should not have found a non-externally-declarable previous decl" ) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\"" , "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 377, __extension__ __PRETTY_FUNCTION__));
378	return true;
379	}
380	return false;
381	}
382	bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
383
384	void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
385	QualType ResultTy,
386	ArrayRef<QualType> Args);
387
388	public:
389	/// The maximum alignment, same as in llvm::Value. We duplicate them here
390	/// because that allows us not to duplicate the constants in clang code,
391	/// which we must to since we can't directly use the llvm constants.
392	/// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp
393	///
394	/// This is the greatest alignment value supported by load, store, and alloca
395	/// instructions, and global values.
396	static const unsigned MaxAlignmentExponent = 29;
397	static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
398
399	typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
400	typedef OpaquePtr<TemplateName> TemplateTy;
401	typedef OpaquePtr<QualType> TypeTy;
402
403	OpenCLOptions OpenCLFeatures;
404	FPOptions CurFPFeatures;
405
406	const LangOptions &LangOpts;
407	Preprocessor &PP;
408	ASTContext &Context;
409	ASTConsumer &Consumer;
410	DiagnosticsEngine &Diags;
411	SourceManager &SourceMgr;
412
413	/// Flag indicating whether or not to collect detailed statistics.
414	bool CollectStats;
415
416	/// Code-completion consumer.
417	CodeCompleteConsumer *CodeCompleter;
418
419	/// CurContext - This is the current declaration context of parsing.
420	DeclContext *CurContext;
421
422	/// Generally null except when we temporarily switch decl contexts,
423	/// like in \see ActOnObjCTemporaryExitContainerContext.
424	DeclContext *OriginalLexicalContext;
425
426	/// VAListTagName - The declaration name corresponding to __va_list_tag.
427	/// This is used as part of a hack to omit that class from ADL results.
428	DeclarationName VAListTagName;
429
430	bool MSStructPragmaOn; // True when \#pragma ms_struct on
431
432	/// Controls member pointer representation format under the MS ABI.
433	LangOptions::PragmaMSPointersToMembersKind
434	MSPointerToMemberRepresentationMethod;
435
436	/// Stack of active SEH __finally scopes. Can be empty.
437	SmallVector<Scope*, 2> CurrentSEHFinally;
438
439	/// Source location for newly created implicit MSInheritanceAttrs
440	SourceLocation ImplicitMSInheritanceAttrLoc;
441
442	/// Holds TypoExprs that are created from `createDelayedTypo`. This is used by
443	/// `TransformTypos` in order to keep track of any TypoExprs that are created
444	/// recursively during typo correction and wipe them away if the correction
445	/// fails.
446	llvm::SmallVector<TypoExpr *, 2> TypoExprs;
447
448	/// pragma clang section kind
449	enum PragmaClangSectionKind {
450	PCSK_Invalid = 0,
451	PCSK_BSS = 1,
452	PCSK_Data = 2,
453	PCSK_Rodata = 3,
454	PCSK_Text = 4,
455	PCSK_Relro = 5
456	};
457
458	enum PragmaClangSectionAction {
459	PCSA_Set = 0,
460	PCSA_Clear = 1
461	};
462
463	struct PragmaClangSection {
464	std::string SectionName;
465	bool Valid = false;
466	SourceLocation PragmaLocation;
467	};
468
469	PragmaClangSection PragmaClangBSSSection;
470	PragmaClangSection PragmaClangDataSection;
471	PragmaClangSection PragmaClangRodataSection;
472	PragmaClangSection PragmaClangRelroSection;
473	PragmaClangSection PragmaClangTextSection;
474
475	enum PragmaMsStackAction {
476	PSK_Reset = 0x0, // #pragma ()
477	PSK_Set = 0x1, // #pragma (value)
478	PSK_Push = 0x2, // #pragma (push[, id])
479	PSK_Pop = 0x4, // #pragma (pop[, id])
480	PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
481	PSK_Push_Set = PSK_Push \| PSK_Set, // #pragma (push[, id], value)
482	PSK_Pop_Set = PSK_Pop \| PSK_Set, // #pragma (pop[, id], value)
483	};
484
485	// #pragma pack and align.
486	class AlignPackInfo {
487	public:
488	// `Native` represents default align mode, which may vary based on the
489	// platform.
490	enum Mode : unsigned char { Native, Natural, Packed, Mac68k };
491
492	// #pragma pack info constructor
493	AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL)
494	: PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
495	assert(Num == PackNumber && "The pack number has been truncated.")(static_cast <bool> (Num == PackNumber && "The pack number has been truncated." ) ? void (0) : __assert_fail ("Num == PackNumber && \"The pack number has been truncated.\"" , "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 495, __extension__ __PRETTY_FUNCTION__));
496	}
497
498	// #pragma align info constructor
499	AlignPackInfo(AlignPackInfo::Mode M, bool IsXL)
500	: PackAttr(false), AlignMode(M),
501	PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {}
502
503	explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {}
504
505	AlignPackInfo() : AlignPackInfo(Native, false) {}
506
507	// When a AlignPackInfo itself cannot be used, this returns an 32-bit
508	// integer encoding for it. This should only be passed to
509	// AlignPackInfo::getFromRawEncoding, it should not be inspected directly.
510	static uint32_t getRawEncoding(const AlignPackInfo &Info) {
511	std::uint32_t Encoding{};
512	if (Info.IsXLStack())
513	Encoding \|= IsXLMask;
514
515	Encoding \|= static_cast<uint32_t>(Info.getAlignMode()) << 1;
516
517	if (Info.IsPackAttr())
518	Encoding \|= PackAttrMask;
519
520	Encoding \|= static_cast<uint32_t>(Info.getPackNumber()) << 4;
521
522	return Encoding;
523	}
524
525	static AlignPackInfo getFromRawEncoding(unsigned Encoding) {
526	bool IsXL = static_cast<bool>(Encoding & IsXLMask);
527	AlignPackInfo::Mode M =
528	static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1);
529	int PackNumber = (Encoding & PackNumMask) >> 4;
530
531	if (Encoding & PackAttrMask)
532	return AlignPackInfo(M, PackNumber, IsXL);
533
534	return AlignPackInfo(M, IsXL);
535	}
536
537	bool IsPackAttr() const { return PackAttr; }
538
539	bool IsAlignAttr() const { return !PackAttr; }
540
541	Mode getAlignMode() const { return AlignMode; }
542
543	unsigned getPackNumber() const { return PackNumber; }
544
545	bool IsPackSet() const {
546	// #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack
547	// attriute on a decl.
548	return PackNumber != UninitPackVal && PackNumber != 0;
549	}
550
551	bool IsXLStack() const { return XLStack; }
552
553	bool operator==(const AlignPackInfo &Info) const {
554	return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
555	std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
556	Info.XLStack);
557	}
558
559	bool operator!=(const AlignPackInfo &Info) const {
560	return !(*this == Info);
561	}
562
563	private:
564	/// \brief True if this is a pragma pack attribute,
565	/// not a pragma align attribute.
566	bool PackAttr;
567
568	/// \brief The alignment mode that is in effect.
569	Mode AlignMode;
570
571	/// \brief The pack number of the stack.
572	unsigned char PackNumber;
573
574	/// \brief True if it is a XL #pragma align/pack stack.
575	bool XLStack;
576
577	/// \brief Uninitialized pack value.
578	static constexpr unsigned char UninitPackVal = -1;
579
580	// Masks to encode and decode an AlignPackInfo.
581	static constexpr uint32_t IsXLMask{0x0000'0001};
582	static constexpr uint32_t AlignModeMask{0x0000'0006};
583	static constexpr uint32_t PackAttrMask{0x00000'0008};
584	static constexpr uint32_t PackNumMask{0x0000'01F0};
585	};
586
587	template<typename ValueType>
588	struct PragmaStack {
589	struct Slot {
590	llvm::StringRef StackSlotLabel;
591	ValueType Value;
592	SourceLocation PragmaLocation;
593	SourceLocation PragmaPushLocation;
594	Slot(llvm::StringRef StackSlotLabel, ValueType Value,
595	SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
596	: StackSlotLabel(StackSlotLabel), Value(Value),
597	PragmaLocation(PragmaLocation),
598	PragmaPushLocation(PragmaPushLocation) {}
599	};
600
601	void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action,
602	llvm::StringRef StackSlotLabel, ValueType Value) {
603	if (Action == PSK_Reset) {
604	CurrentValue = DefaultValue;
605	CurrentPragmaLocation = PragmaLocation;
606	return;
607	}
608	if (Action & PSK_Push)
609	Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
610	PragmaLocation);
611	else if (Action & PSK_Pop) {
612	if (!StackSlotLabel.empty()) {
613	// If we've got a label, try to find it and jump there.
614	auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
615	return x.StackSlotLabel == StackSlotLabel;
616	});
617	// If we found the label so pop from there.
618	if (I != Stack.rend()) {
619	CurrentValue = I->Value;
620	CurrentPragmaLocation = I->PragmaLocation;
621	Stack.erase(std::prev(I.base()), Stack.end());
622	}
623	} else if (!Stack.empty()) {
624	// We do not have a label, just pop the last entry.
625	CurrentValue = Stack.back().Value;
626	CurrentPragmaLocation = Stack.back().PragmaLocation;
627	Stack.pop_back();
628	}
629	}
630	if (Action & PSK_Set) {
631	CurrentValue = Value;
632	CurrentPragmaLocation = PragmaLocation;
633	}
634	}
635
636	// MSVC seems to add artificial slots to #pragma stacks on entering a C++
637	// method body to restore the stacks on exit, so it works like this:
638	//
639	// struct S {
640	// #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
641	// void Method {}
642	// #pragma <name>(pop, InternalPragmaSlot)
643	// };
644	//
645	// It works even with #pragma vtordisp, although MSVC doesn't support
646	// #pragma vtordisp(push [, id], n)
647	// syntax.
648	//
649	// Push / pop a named sentinel slot.
650	void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
651	assert((Action == PSK_Push \|\| Action == PSK_Pop) &&(static_cast <bool> ((Action == PSK_Push \|\| Action == PSK_Pop ) && "Can only push / pop #pragma stack sentinels!") ? void (0) : __assert_fail ("(Action == PSK_Push \|\| Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\"" , "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 652, __extension__ __PRETTY_FUNCTION__))
652	"Can only push / pop #pragma stack sentinels!")(static_cast <bool> ((Action == PSK_Push \|\| Action == PSK_Pop ) && "Can only push / pop #pragma stack sentinels!") ? void (0) : __assert_fail ("(Action == PSK_Push \|\| Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\"" , "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 652, __extension__ __PRETTY_FUNCTION__));
653	Act(CurrentPragmaLocation, Action, Label, CurrentValue);
654	}
655
656	// Constructors.
657	explicit PragmaStack(const ValueType &Default)
658	: DefaultValue(Default), CurrentValue(Default) {}
659
660	bool hasValue() const { return CurrentValue != DefaultValue; }
661
662	SmallVector<Slot, 2> Stack;
663	ValueType DefaultValue; // Value used for PSK_Reset action.
664	ValueType CurrentValue;
665	SourceLocation CurrentPragmaLocation;
666	};
667	// FIXME: We should serialize / deserialize these if they occur in a PCH (but
668	// we shouldn't do so if they're in a module).
669
670	/// Whether to insert vtordisps prior to virtual bases in the Microsoft
671	/// C++ ABI. Possible values are 0, 1, and 2, which mean:
672	///
673	/// 0: Suppress all vtordisps
674	/// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
675	/// structors
676	/// 2: Always insert vtordisps to support RTTI on partially constructed
677	/// objects
678	PragmaStack<MSVtorDispMode> VtorDispStack;
679	PragmaStack<AlignPackInfo> AlignPackStack;
680	// The current #pragma align/pack values and locations at each #include.
681	struct AlignPackIncludeState {
682	AlignPackInfo CurrentValue;
683	SourceLocation CurrentPragmaLocation;
684	bool HasNonDefaultValue, ShouldWarnOnInclude;
685	};
686	SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack;
687	// Segment #pragmas.
688	PragmaStack<StringLiteral *> DataSegStack;
689	PragmaStack<StringLiteral *> BSSSegStack;
690	PragmaStack<StringLiteral *> ConstSegStack;
691	PragmaStack<StringLiteral *> CodeSegStack;
692
693	// This stack tracks the current state of Sema.CurFPFeatures.
694	PragmaStack<FPOptionsOverride> FpPragmaStack;
695	FPOptionsOverride CurFPFeatureOverrides() {
696	FPOptionsOverride result;
697	if (!FpPragmaStack.hasValue()) {
698	result = FPOptionsOverride();
699	} else {
700	result = FpPragmaStack.CurrentValue;
701	}
702	return result;
703	}
704
705	// RAII object to push / pop sentinel slots for all MS #pragma stacks.
706	// Actions should be performed only if we enter / exit a C++ method body.
707	class PragmaStackSentinelRAII {
708	public:
709	PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
710	~PragmaStackSentinelRAII();
711
712	private:
713	Sema &S;
714	StringRef SlotLabel;
715	bool ShouldAct;
716	};
717
718	/// A mapping that describes the nullability we've seen in each header file.
719	FileNullabilityMap NullabilityMap;
720
721	/// Last section used with #pragma init_seg.
722	StringLiteral *CurInitSeg;
723	SourceLocation CurInitSegLoc;
724
725	/// VisContext - Manages the stack for \#pragma GCC visibility.
726	void VisContext; // Really a "PragmaVisStack"
727
728	/// This an attribute introduced by \#pragma clang attribute.
729	struct PragmaAttributeEntry {
730	SourceLocation Loc;
731	ParsedAttr *Attribute;
732	SmallVector<attr::SubjectMatchRule, 4> MatchRules;
733	bool IsUsed;
734	};
735
736	/// A push'd group of PragmaAttributeEntries.
737	struct PragmaAttributeGroup {
738	/// The location of the push attribute.
739	SourceLocation Loc;
740	/// The namespace of this push group.
741	const IdentifierInfo *Namespace;
742	SmallVector<PragmaAttributeEntry, 2> Entries;
743	};
744
745	SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;
746
747	/// The declaration that is currently receiving an attribute from the
748	/// #pragma attribute stack.
749	const Decl *PragmaAttributeCurrentTargetDecl;
750
751	/// This represents the last location of a "#pragma clang optimize off"
752	/// directive if such a directive has not been closed by an "on" yet. If
753	/// optimizations are currently "on", this is set to an invalid location.
754	SourceLocation OptimizeOffPragmaLocation;
755
756	/// Flag indicating if Sema is building a recovery call expression.
757	///
758	/// This flag is used to avoid building recovery call expressions
759	/// if Sema is already doing so, which would cause infinite recursions.
760	bool IsBuildingRecoveryCallExpr;
761
762	/// Used to control the generation of ExprWithCleanups.
763	CleanupInfo Cleanup;
764
765	/// ExprCleanupObjects - This is the stack of objects requiring
766	/// cleanup that are created by the current full expression.
767	SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;
768
769	/// Store a set of either DeclRefExprs or MemberExprs that contain a reference
770	/// to a variable (constant) that may or may not be odr-used in this Expr, and
771	/// we won't know until all lvalue-to-rvalue and discarded value conversions
772	/// have been applied to all subexpressions of the enclosing full expression.
773	/// This is cleared at the end of each full expression.
774	using MaybeODRUseExprSet = llvm::SetVector<Expr , SmallVector<Expr , 4>,
775	llvm::SmallPtrSet<Expr *, 4>>;
776	MaybeODRUseExprSet MaybeODRUseExprs;
777
778	std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
779
780	/// Stack containing information about each of the nested
781	/// function, block, and method scopes that are currently active.
782	SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
783
784	/// The index of the first FunctionScope that corresponds to the current
785	/// context.
786	unsigned FunctionScopesStart = 0;
787
788	ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {
789	return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart,
790	FunctionScopes.end());
791	}
792
793	/// Stack containing information needed when in C++2a an 'auto' is encountered
794	/// in a function declaration parameter type specifier in order to invent a
795	/// corresponding template parameter in the enclosing abbreviated function
796	/// template. This information is also present in LambdaScopeInfo, stored in
797	/// the FunctionScopes stack.
798	SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos;
799
800	/// The index of the first InventedParameterInfo that refers to the current
801	/// context.
802	unsigned InventedParameterInfosStart = 0;
803
804	ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
805	return llvm::makeArrayRef(InventedParameterInfos.begin() +
806	InventedParameterInfosStart,
807	InventedParameterInfos.end());
808	}
809
810	typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
811	&ExternalSemaSource::ReadExtVectorDecls, 2, 2>
812	ExtVectorDeclsType;
813
814	/// ExtVectorDecls - This is a list all the extended vector types. This allows
815	/// us to associate a raw vector type with one of the ext_vector type names.
816	/// This is only necessary for issuing pretty diagnostics.
817	ExtVectorDeclsType ExtVectorDecls;
818
819	/// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
820	std::unique_ptr<CXXFieldCollector> FieldCollector;
821
822	typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
823
824	/// Set containing all declared private fields that are not used.
825	NamedDeclSetType UnusedPrivateFields;
826
827	/// Set containing all typedefs that are likely unused.
828	llvm::SmallSetVector<const TypedefNameDecl *, 4>
829	UnusedLocalTypedefNameCandidates;
830
831	/// Delete-expressions to be analyzed at the end of translation unit
832	///
833	/// This list contains class members, and locations of delete-expressions
834	/// that could not be proven as to whether they mismatch with new-expression
835	/// used in initializer of the field.
836	typedef std::pair<SourceLocation, bool> DeleteExprLoc;
837	typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
838	llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
839
840	typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
841
842	/// PureVirtualClassDiagSet - a set of class declarations which we have
843	/// emitted a list of pure virtual functions. Used to prevent emitting the
844	/// same list more than once.
845	std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
846
847	/// ParsingInitForAutoVars - a set of declarations with auto types for which
848	/// we are currently parsing the initializer.
849	llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
850
851	/// Look for a locally scoped extern "C" declaration by the given name.
852	NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
853
854	typedef LazyVector<VarDecl *, ExternalSemaSource,
855	&ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
856	TentativeDefinitionsType;
857
858	/// All the tentative definitions encountered in the TU.
859	TentativeDefinitionsType TentativeDefinitions;
860
861	/// All the external declarations encoutered and used in the TU.
862	SmallVector<VarDecl *, 4> ExternalDeclarations;
863
864	typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
865	&ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
866	UnusedFileScopedDeclsType;
867
868	/// The set of file scoped decls seen so far that have not been used
869	/// and must warn if not used. Only contains the first declaration.
870	UnusedFileScopedDeclsType UnusedFileScopedDecls;
871
872	typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
873	&ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
874	DelegatingCtorDeclsType;
875
876	/// All the delegating constructors seen so far in the file, used for
877	/// cycle detection at the end of the TU.
878	DelegatingCtorDeclsType DelegatingCtorDecls;
879
880	/// All the overriding functions seen during a class definition
881	/// that had their exception spec checks delayed, plus the overridden
882	/// function.
883	SmallVector<std::pair<const CXXMethodDecl, const CXXMethodDecl>, 2>
884	DelayedOverridingExceptionSpecChecks;
885
886	/// All the function redeclarations seen during a class definition that had
887	/// their exception spec checks delayed, plus the prior declaration they
888	/// should be checked against. Except during error recovery, the new decl
889	/// should always be a friend declaration, as that's the only valid way to
890	/// redeclare a special member before its class is complete.
891	SmallVector<std::pair<FunctionDecl, FunctionDecl>, 2>
892	DelayedEquivalentExceptionSpecChecks;
893
894	typedef llvm::MapVector<const FunctionDecl *,
895	std::unique_ptr<LateParsedTemplate>>
896	LateParsedTemplateMapT;
897	LateParsedTemplateMapT LateParsedTemplateMap;
898
899	/// Callback to the parser to parse templated functions when needed.
900	typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
901	typedef void LateTemplateParserCleanupCB(void *P);
902	LateTemplateParserCB *LateTemplateParser;
903	LateTemplateParserCleanupCB *LateTemplateParserCleanup;
904	void *OpaqueParser;
905
906	void SetLateTemplateParser(LateTemplateParserCB *LTP,
907	LateTemplateParserCleanupCB *LTPCleanup,
908	void *P) {
909	LateTemplateParser = LTP;
910	LateTemplateParserCleanup = LTPCleanup;
911	OpaqueParser = P;
912	}
913
914	class DelayedDiagnostics;
915
916	class DelayedDiagnosticsState {
917	sema::DelayedDiagnosticPool *SavedPool;
918	friend class Sema::DelayedDiagnostics;
919	};
920	typedef DelayedDiagnosticsState ParsingDeclState;
921	typedef DelayedDiagnosticsState ProcessingContextState;
922
923	/// A class which encapsulates the logic for delaying diagnostics
924	/// during parsing and other processing.
925	class DelayedDiagnostics {
926	/// The current pool of diagnostics into which delayed
927	/// diagnostics should go.
928	sema::DelayedDiagnosticPool *CurPool;
929
930	public:
931	DelayedDiagnostics() : CurPool(nullptr) {}
932
933	/// Adds a delayed diagnostic.
934	void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
935
936	/// Determines whether diagnostics should be delayed.
937	bool shouldDelayDiagnostics() { return CurPool != nullptr; }
938
939	/// Returns the current delayed-diagnostics pool.
940	sema::DelayedDiagnosticPool *getCurrentPool() const {
941	return CurPool;
942	}
943
944	/// Enter a new scope. Access and deprecation diagnostics will be
945	/// collected in this pool.
946	DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
947	DelayedDiagnosticsState state;
948	state.SavedPool = CurPool;
949	CurPool = &pool;
950	return state;
951	}
952
953	/// Leave a delayed-diagnostic state that was previously pushed.
954	/// Do not emit any of the diagnostics. This is performed as part
955	/// of the bookkeeping of popping a pool "properly".
956	void popWithoutEmitting(DelayedDiagnosticsState state) {
957	CurPool = state.SavedPool;
958	}
959
960	/// Enter a new scope where access and deprecation diagnostics are
961	/// not delayed.
962	DelayedDiagnosticsState pushUndelayed() {
963	DelayedDiagnosticsState state;
964	state.SavedPool = CurPool;
965	CurPool = nullptr;
966	return state;
967	}
968
969	/// Undo a previous pushUndelayed().
970	void popUndelayed(DelayedDiagnosticsState state) {
971	assert(CurPool == nullptr)(static_cast <bool> (CurPool == nullptr) ? void (0) : __assert_fail ("CurPool == nullptr", "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 971, __extension__ __PRETTY_FUNCTION__));
972	CurPool = state.SavedPool;
973	}
974	} DelayedDiagnostics;
975
976	/// A RAII object to temporarily push a declaration context.
977	class ContextRAII {
978	private:
979	Sema &S;
980	DeclContext *SavedContext;
981	ProcessingContextState SavedContextState;
982	QualType SavedCXXThisTypeOverride;
983	unsigned SavedFunctionScopesStart;
984	unsigned SavedInventedParameterInfosStart;
985
986	public:
987	ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
988	: S(S), SavedContext(S.CurContext),
989	SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
990	SavedCXXThisTypeOverride(S.CXXThisTypeOverride),
991	SavedFunctionScopesStart(S.FunctionScopesStart),
992	SavedInventedParameterInfosStart(S.InventedParameterInfosStart)
993	{
994	assert(ContextToPush && "pushing null context")(static_cast <bool> (ContextToPush && "pushing null context" ) ? void (0) : __assert_fail ("ContextToPush && \"pushing null context\"" , "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 994, __extension__ __PRETTY_FUNCTION__));
995	S.CurContext = ContextToPush;
996	if (NewThisContext)
997	S.CXXThisTypeOverride = QualType();
998	// Any saved FunctionScopes do not refer to this context.
999	S.FunctionScopesStart = S.FunctionScopes.size();
1000	S.InventedParameterInfosStart = S.InventedParameterInfos.size();
1001	}
1002
1003	void pop() {
1004	if (!SavedContext) return;
1005	S.CurContext = SavedContext;
1006	S.DelayedDiagnostics.popUndelayed(SavedContextState);
1007	S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
1008	S.FunctionScopesStart = SavedFunctionScopesStart;
1009	S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1010	SavedContext = nullptr;
1011	}
1012
1013	~ContextRAII() {
1014	pop();
1015	}
1016	};
1017
1018	/// Whether the AST is currently being rebuilt to correct immediate
1019	/// invocations. Immediate invocation candidates and references to consteval
1020	/// functions aren't tracked when this is set.
1021	bool RebuildingImmediateInvocation = false;
1022
1023	/// Used to change context to isConstantEvaluated without pushing a heavy
1024	/// ExpressionEvaluationContextRecord object.
1025	bool isConstantEvaluatedOverride;
1026
1027	bool isConstantEvaluated() {
1028	return ExprEvalContexts.back().isConstantEvaluated() \|\|
1029	isConstantEvaluatedOverride;
1030	}
1031
1032	/// RAII object to handle the state changes required to synthesize
1033	/// a function body.
1034	class SynthesizedFunctionScope {
1035	Sema &S;
1036	Sema::ContextRAII SavedContext;
1037	bool PushedCodeSynthesisContext = false;
1038
1039	public:
1040	SynthesizedFunctionScope(Sema &S, DeclContext *DC)
1041	: S(S), SavedContext(S, DC) {
1042	S.PushFunctionScope();
1043	S.PushExpressionEvaluationContext(
1044	Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1045	if (auto *FD = dyn_cast<FunctionDecl>(DC))
1046	FD->setWillHaveBody(true);
1047	else
1048	assert(isa<ObjCMethodDecl>(DC))(static_cast <bool> (isa<ObjCMethodDecl>(DC)) ? void (0) : __assert_fail ("isa<ObjCMethodDecl>(DC)", "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 1048, __extension__ __PRETTY_FUNCTION__));
1049	}
1050
1051	void addContextNote(SourceLocation UseLoc) {
1052	assert(!PushedCodeSynthesisContext)(static_cast <bool> (!PushedCodeSynthesisContext) ? void (0) : __assert_fail ("!PushedCodeSynthesisContext", "/build/llvm-toolchain-snapshot-13~++20210506100649+6304c0836a4d/clang/include/clang/Sema/Sema.h" , 1052, __extension__ __PRETTY_FUNCTION__));
1053
1054	Sema::CodeSynthesisContext Ctx;
1055	Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
1056	Ctx.PointOfInstantiation = UseLoc;
1057	Ctx.Entity = cast<Decl>(S.CurContext);
1058	S.pushCodeSynthesisContext(Ctx);
1059
1060	PushedCodeSynthesisContext = true;
1061	}
1062
1063	~SynthesizedFunctionScope() {
1064	if (PushedCodeSynthesisContext)
1065	S.popCodeSynthesisContext();
1066	if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
1067	FD->setWillHaveBody(false);
1068	S.PopExpressionEvaluationContext();
1069	S.PopFunctionScopeInfo();
1070	}
1071	};
1072
1073	/// WeakUndeclaredIdentifiers - Identifiers contained in
1074	/// \#pragma weak before declared. rare. may alias another
1075	/// identifier, declared or undeclared
1076	llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
1077
1078	/// ExtnameUndeclaredIdentifiers - Identifiers contained in
1079	/// \#pragma redefine_extname before declared. Used in Solaris system headers
1080	/// to define functions that occur in multiple standards to call the version
1081	/// in the currently selected standard.
1082	llvm::DenseMap<IdentifierInfo,AsmLabelAttr> ExtnameUndeclaredIdentifiers;
1083
1084
1085	/// Load weak undeclared identifiers from the external source.
1086	void LoadExternalWeakUndeclaredIdentifiers();
1087
1088	/// WeakTopLevelDecl - Translation-unit scoped declarations generated by
1089	/// \#pragma weak during processing of other Decls.
1090	/// I couldn't figure out a clean way to generate these in-line, so
1091	/// we store them here and handle separately -- which is a hack.
1092	/// It would be best to refactor this.
1093	SmallVector<Decl*,2> WeakTopLevelDecl;
1094
1095	IdentifierResolver IdResolver;
1096
1097	/// Translation Unit Scope - useful to Objective-C actions that need
1098	/// to lookup file scope declarations in the "ordinary" C decl namespace.
1099	/// For example, user-defined classes, built-in "id" type, etc.
1100	Scope *TUScope;
1101
1102	/// The C++ "std" namespace, where the standard library resides.
1103	LazyDeclPtr StdNamespace;
1104
1105	/// The C++ "std::bad_alloc" class, which is defined by the C++
1106	/// standard library.
1107	LazyDeclPtr StdBadAlloc;
1108
1109	/// The C++ "std::align_val_t" enum class, which is defined by the C++
1110	/// standard library.
1111	LazyDeclPtr StdAlignValT;
1112
1113	/// The C++ "std::experimental" namespace, where the experimental parts
1114	/// of the standard library resides.
1115	NamespaceDecl *StdExperimentalNamespaceCache;
1116
1117	/// The C++ "std::initializer_list" template, which is defined in
1118	/// \<initializer_list>.
1119	ClassTemplateDecl *StdInitializerList;
1120
1121	/// The C++ "std::coroutine_traits" template, which is defined in
1122	/// \<coroutine_traits>
1123	ClassTemplateDecl *StdCoroutineTraitsCache;
1124
1125	/// The C++ "type_info" declaration, which is defined in \<typeinfo>.
1126	RecordDecl *CXXTypeInfoDecl;
1127
1128	/// The MSVC "_GUID" struct, which is defined in MSVC header files.
1129	RecordDecl *MSVCGuidDecl;
1130
1131	/// Caches identifiers/selectors for NSFoundation APIs.
1132	std::unique_ptr<NSAPI> NSAPIObj;
1133
1134	/// The declaration of the Objective-C NSNumber class.
1135	ObjCInterfaceDecl *NSNumberDecl;
1136
1137	/// The declaration of the Objective-C NSValue class.
1138	ObjCInterfaceDecl *NSValueDecl;
1139
1140	/// Pointer to NSNumber type (NSNumber *).
1141	QualType NSNumberPointer;
1142
1143	/// Pointer to NSValue type (NSValue *).
1144	QualType NSValuePointer;
1145
1146	/// The Objective-C NSNumber methods used to create NSNumber literals.
1147	ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
1148
1149	/// The declaration of the Objective-C NSString class.
1150	ObjCInterfaceDecl *NSStringDecl;
1151
1152	/// Pointer to NSString type (NSString *).
1153	QualType NSStringPointer;
1154
1155	/// The declaration of the stringWithUTF8String: method.
1156	ObjCMethodDecl *StringWithUTF8StringMethod;
1157
1158	/// The declaration of the valueWithBytes:objCType: method.
1159	ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
1160
1161	/// The declaration of the Objective-C NSArray class.
1162	ObjCInterfaceDecl *NSArrayDecl;
1163
1164	/// The declaration of the arrayWithObjects:count: method.
1165	ObjCMethodDecl *ArrayWithObjectsMethod;
1166
1167	/// The declaration of the Objective-C NSDictionary class.
1168	ObjCInterfaceDecl *NSDictionaryDecl;
1169
1170	/// The declaration of the dictionaryWithObjects:forKeys:count: method.
1171	ObjCMethodDecl *DictionaryWithObjectsMethod;
1172
1173	/// id<NSCopying> type.
1174	QualType QIDNSCopying;
1175
1176	/// will hold 'respondsToSelector:'
1177	Selector RespondsToSelectorSel;
1178
1179	/// A flag to remember whether the implicit forms of operator new and delete
1180	/// have been declared.
1181	bool GlobalNewDeleteDeclared;
1182
1183	/// Describes how the expressions currently being parsed are
1184	/// evaluated at run-time, if at all.
1185	enum class ExpressionEvaluationContext {
1186	/// The current expression and its subexpressions occur within an
1187	/// unevaluated operand (C++11 [expr]p7), such as the subexpression of
1188	/// \c sizeof, where the type of the expression may be significant but
1189	/// no code will be generated to evaluate the value of the expression at
1190	/// run time.
1191	Unevaluated,
1192
1193	/// The current expression occurs within a braced-init-list within
1194	/// an unevaluated operand. This is mostly like a regular unevaluated
1195	/// context, except that we still instantiate constexpr functions that are
1196	/// referenced here so that we can perform narrowing checks correctly.
1197	UnevaluatedList,
1198
1199	/// The current expression occurs within a discarded statement.
1200	/// This behaves largely similarly to an unevaluated operand in preventing
1201	/// definitions from being required, but not in other ways.
1202	DiscardedStatement,
1203
1204	/// The current expression occurs within an unevaluated
1205	/// operand that unconditionally permits abstract references to
1206	/// fields, such as a SIZE operator in MS-style inline assembly.
1207	UnevaluatedAbstract,
1208
1209	/// The current context is "potentially evaluated" in C++11 terms,
1210	/// but the expression is evaluated at compile-time (like the values of
1211	/// cases in a switch statement).
1212	ConstantEvaluated,
1213
1214	/// The current expression is potentially evaluated at run time,
1215	/// which means that code may be generated to evaluate the value of the
1216	/// expression at run time.
1217	PotentiallyEvaluated,
1218
1219	/// The current expression is potentially evaluated, but any
1220	/// declarations referenced inside that expression are only used if
1221	/// in fact the current expression is used.
1222	///
1223	/// This value is used when parsing default function arguments, for which
1224	/// we would like to provide diagnostics (e.g., passing non-POD arguments
1225	/// through varargs) but do not want to mark declarations as "referenced"
1226	/// until the default argument is used.
1227	PotentiallyEvaluatedIfUsed
1228	};
1229
1230	using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;
1231
1232	/// Data structure used to record current or nested
1233	/// expression evaluation contexts.
1234	struct ExpressionEvaluationContextRecord {
1235	/// The expression evaluation context.
1236	ExpressionEvaluationContext Context;
1237
1238	/// Whether the enclosing context needed a cleanup.
1239	CleanupInfo ParentCleanup;
1240
1241	/// The number of active cleanup objects when we entered
1242	/// this expression evaluation context.
1243	unsigned NumCleanupObjects;
1244
1245	/// The number of typos encountered during this expression evaluation
1246	/// context (i.e. the number of TypoExprs created).
1247	unsigned NumTypos;
1248
1249	MaybeODRUseExprSet SavedMaybeODRUseExprs;
1250
1251	/// The lambdas that are present within this context, if it
1252	/// is indeed an unevaluated context.
1253	SmallVector<LambdaExpr *, 2> Lambdas;
1254
1255	/// The declaration that provides context for lambda expressions
1256	/// and block literals if the normal declaration context does not
1257	/// suffice, e.g., in a default function argument.
1258	Decl *ManglingContextDecl;
1259
1260	/// If we are processing a decltype type, a set of call expressions
1261	/// for which we have deferred checking the completeness of the return type.
1262	SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
1263
1264	/// If we are processing a decltype type, a set of temporary binding
1265	/// expressions for which we have deferred checking the destructor.
1266	SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
1267
1268	llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
1269
1270	/// Expressions appearing as the LHS of a volatile assignment in this
1271	/// context. We produce a warning for these when popping the context if
1272	/// they are not discarded-value expressions nor unevaluated operands.
1273	SmallVector<Expr*, 2> VolatileAssignmentLHSs;
1274
1275	/// Set of candidates for starting an immediate invocation.
1276	llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates;
1277
1278	/// Set of DeclRefExprs referencing a consteval function when used in a
1279	/// context not already known to be immediately invoked.
1280	llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval;
1281
1282	/// \brief Describes whether we are in an expression constext which we have
1283	/// to handle differently.
1284	enum ExpressionKind {
1285	EK_Decltype, EK_TemplateArgument, EK_Other
1286	} ExprContext;
1287
1288	ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
1289	unsigned NumCleanupObjects,
1290	CleanupInfo ParentCleanup,
1291	Decl *ManglingContextDecl,
1292	ExpressionKind ExprContext)
1293	: Context(Context), ParentCleanup(ParentCleanup),
1294	NumCleanupObjects(NumCleanupObjects), NumTypos(0),
1295	ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {}
1296
1297	bool isUnevaluated() const {
1298	return Context == ExpressionEvaluationContext::Unevaluated \|\|
1299	Context == ExpressionEvaluationContext::UnevaluatedAbstract \|\|
1300	Context == ExpressionEvaluationContext::UnevaluatedList;
1301	}
1302	bool isConstantEvaluated() const {
1303	return Context == ExpressionEvaluationContext::ConstantEvaluated;
1304	}
1305	};
1306
1307	/// A stack of expression evaluation contexts.
1308	SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1309
1310	/// Emit a warning for all pending noderef expressions that we recorded.
1311	void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
1312
1313	/// Compute the mangling number context for a lambda expression or
1314	/// block literal. Also return the extra mangling decl if any.
1315	///
1316	/// \param DC - The DeclContext containing the lambda expression or
1317	/// block literal.
1318	std::tuple<MangleNumberingContext , Decl >
1319	getCurrentMangleNumberContext(const DeclContext *DC);
1320
1321
1322	/// SpecialMemberOverloadResult - The overloading result for a special member
1323	/// function.
1324	///
1325	/// This is basically a wrapper around PointerIntPair. The lowest bits of the
1326	/// integer are used to determine whether overload resolution succeeded.
1327	class SpecialMemberOverloadResult {
1328	public:
1329	enum Kind {
1330	NoMemberOrDeleted,
1331	Ambiguous,
1332	Success
1333	};
1334
1335	private:
1336	llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1337
1338	public:
1339	SpecialMemberOverloadResult() : Pair() {}
1340	SpecialMemberOverloadResult(CXXMethodDecl *MD)
1341	: Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1342
1343	CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1344	void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1345
1346	Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1347	void setKind(Kind K) { Pair.setInt(K); }
1348	};
1349
1350	class SpecialMemberOverloadResultEntry
1351	: public llvm::FastFoldingSetNode,
1352	public SpecialMemberOverloadResult {
1353	public:
1354	SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1355	: FastFoldingSetNode(ID)
1356	{}
1357	};
1358
1359	/// A cache of special member function overload resolution results
1360	/// for C++ records.
1361	llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1362
1363	/// A cache of the flags available in enumerations with the flag_bits
1364	/// attribute.
1365	mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1366
1367	/// The kind of translation unit we are processing.
1368	///
1369	/// When we're processing a complete translation unit, Sema will perform
1370	/// end-of-translation-unit semantic tasks (such as creating
1371	/// initializers for tentative definitions in C) once parsing has
1372	/// completed. Modules and precompiled headers perform different kinds of
1373	/// checks.
1374	TranslationUnitKind TUKind;
1375
1376	llvm::BumpPtrAllocator BumpAlloc;
1377
1378	/// The number of SFINAE diagnostics that have been trapped.
1379	unsigned NumSFINAEErrors;
1380
1381	typedef llvm::DenseMap<ParmVarDecl , llvm::TinyPtrVector<ParmVarDecl >>
1382	UnparsedDefaultArgInstantiationsMap;
1383
1384	/// A mapping from parameters with unparsed default arguments to the
1385	/// set of instantiations of each parameter.
1386	///
1387	/// This mapping is a temporary data structure used when parsing
1388	/// nested class templates or nested classes of class templates,
1389	/// where we might end up instantiating an inner class before the
1390	/// default arguments of its methods have been parsed.
1391	UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1392
1393	// Contains the locations of the beginning of unparsed default
1394	// argument locations.
1395	llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1396
1397	/// UndefinedInternals - all the used, undefined objects which require a
1398	/// definition in this translation unit.
1399	llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1400
1401	/// Determine if VD, which must be a variable or function, is an external
1402	/// symbol that nonetheless can't be referenced from outside this translation
1403	/// unit because its type has no linkage and it's not extern "C".
1404	bool isExternalWithNoLinkageType(ValueDecl *VD);
1405
1406	/// Obtain a sorted list of functions that are undefined but ODR-used.
1407	void getUndefinedButUsed(
1408	SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1409
1410	/// Retrieves list of suspicious delete-expressions that will be checked at
1411	/// the end of translation unit.
1412	const llvm::MapVector<FieldDecl *, DeleteLocs> &
1413	getMismatchingDeleteExpressions() const;
1414
1415	typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1416	typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1417
1418	/// Method Pool - allows efficient lookup when typechecking messages to "id".
1419	/// We need to maintain a list, since selectors can have differing signatures
1420	/// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1421	/// of selectors are "overloaded").
1422	/// At the head of the list it is recorded whether there were 0, 1, or >= 2
1423	/// methods inside categories with a particular selector.
1424	GlobalMethodPool MethodPool;
1425
1426	/// Method selectors used in a \@selector expression. Used for implementation
1427	/// of -Wselector.
1428	llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1429
1430	/// List of SourceLocations where 'self' is implicitly retained inside a
1431	/// block.
1432	llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1>
1433	ImplicitlyRetainedSelfLocs;
1434
1435	/// Kinds of C++ special members.
1436	enum CXXSpecialMember {
1437	CXXDefaultConstructor,
1438	CXXCopyConstructor,
1439	CXXMoveConstructor,
1440	CXXCopyAssignment,
1441	CXXMoveAssignment,
1442	CXXDestructor,
1443	CXXInvalid
1444	};
1445
1446	typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1447	SpecialMemberDecl;
1448
1449	/// The C++ special members which we are currently in the process of
1450	/// declaring. If this process recursively triggers the declaration of the
1451	/// same special member, we should act as if it is not yet declared.
1452	llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1453
1454	/// Kinds of defaulted comparison operator functions.
1455	enum class DefaultedComparisonKind : unsigned char {
1456	/// This is not a defaultable comparison operator.
1457	None,
1458	/// This is an operator== that should be implemented as a series of
1459	/// subobject comparisons.
1460	Equal,
1461	/// This is an operator<=> that should be implemented as a series of
1462	/// subobject comparisons.
1463	ThreeWay,
1464	/// This is an operator!= that should be implemented as a rewrite in terms
1465	/// of a == comparison.
1466	NotEqual,
1467	/// This is an <, <=, >, or >= that should be implemented as a rewrite in
1468	/// terms of a <=> comparison.
1469	Relational,
1470	};
1471
1472	/// The function definitions which were renamed as part of typo-correction
1473	/// to match their respective declarations. We want to keep track of them
1474	/// to ensure that we don't emit a "redefinition" error if we encounter a
1475	/// correctly named definition after the renamed definition.
1476	llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1477
1478	/// Stack of types that correspond to the parameter entities that are
1479	/// currently being copy-initialized. Can be empty.
1480	llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1481
1482	void ReadMethodPool(Selector Sel);
1483	void updateOutOfDateSelector(Selector Sel);
1484
1485	/// Private Helper predicate to check for 'self'.
1486	bool isSelfExpr(Expr *RExpr);
1487	bool isSelfExpr(Expr RExpr, const ObjCMethodDecl Method);
1488
1489	/// Cause the active diagnostic on the DiagosticsEngine to be
1490	/// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1491	/// should not be used elsewhere.
1492	void EmitCurrentDiagnostic(unsigned DiagID);
1493
1494	/// Records and restores the CurFPFeatures state on entry/exit of compound
1495	/// statements.
1496	class FPFeaturesStateRAII {
1497	public:
1498	FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) {
1499	OldOverrides = S.FpPragmaStack.CurrentValue;
1500	}
1501	~FPFeaturesStateRAII() {
1502	S.CurFPFeatures = OldFPFeaturesState;
1503	S.FpPragmaStack.CurrentValue = OldOverrides;
1504	}
1505	FPOptionsOverride getOverrides() { return OldOverrides; }
1506
1507	private:
1508	Sema& S;
1509	FPOptions OldFPFeaturesState;
1510	FPOptionsOverride OldOverrides;
1511	};
1512
1513	void addImplicitTypedef(StringRef Name, QualType T);
1514
1515	bool WarnedStackExhausted = false;
1516
1517	public:
1518	Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1519	TranslationUnitKind TUKind = TU_Complete,
1520	CodeCompleteConsumer *CompletionConsumer = nullptr);
1521	~Sema();
1522
1523	/// Perform initialization that occurs after the parser has been
1524	/// initialized but before it parses anything.
1525	void Initialize();
1526
1527	/// This virtual key function only exists to limit the emission of debug info
1528	/// describing the Sema class. GCC and Clang only emit debug info for a class
1529	/// with a vtable when the vtable is emitted. Sema is final and not
1530	/// polymorphic, but the debug info size savings are so significant that it is
1531	/// worth adding a vtable just to take advantage of this optimization.
1532	virtual void anchor();
1533
1534	const LangOptions &getLangOpts() const { return LangOpts; }
1535	OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1536	FPOptions &getCurFPFeatures() { return CurFPFeatures; }
1537
1538	DiagnosticsEngine &getDiagnostics() const { return Diags; }
1539	SourceManager &getSourceManager() const { return SourceMgr; }
1540	Preprocessor &getPreprocessor() const { return PP; }
1541	ASTContext &getASTContext() const { return Context; }
1542	ASTConsumer &getASTConsumer() const { return Consumer; }
1543	ASTMutationListener *getASTMutationListener() const;
1544	ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1545
1546	///Registers an external source. If an external source already exists,
1547	/// creates a multiplex external source and appends to it.
1548	///
1549	///\param[in] E - A non-null external sema source.
1550	///
1551	void addExternalSource(ExternalSemaSource *E);
1552
1553	void PrintStats() const;
1554
1555	/// Warn that the stack is nearly exhausted.
1556	void warnStackExhausted(SourceLocation Loc);
1557
1558	/// Run some code with "sufficient" stack space. (Currently, at least 256K is
1559	/// guaranteed). Produces a warning if we're low on stack space and allocates
1560	/// more in that case. Use this in code that may recurse deeply (for example,
1561	/// in template instantiation) to avoid stack overflow.
1562	void runWithSufficientStackSpace(SourceLocation Loc,
1563	llvm::function_ref<void()> Fn);
1564
1565	/// Helper class that creates diagnostics with optional
1566	/// template instantiation stacks.
1567	///
1568	/// This class provides a wrapper around the basic DiagnosticBuilder
1569	/// class that emits diagnostics. ImmediateDiagBuilder is
1570	/// responsible for emitting the diagnostic (as DiagnosticBuilder
1571	/// does) and, if the diagnostic comes from inside a template
1572	/// instantiation, printing the template instantiation stack as
1573	/// well.
1574	class ImmediateDiagBuilder : public DiagnosticBuilder {
1575	Sema &SemaRef;
1576	unsigned DiagID;
1577
1578	public:
1579	ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1580	: DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1581	ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)
1582	: DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1583
1584	// This is a cunning lie. DiagnosticBuilder actually performs move
1585	// construction in its copy constructor (but due to varied uses, it's not
1586	// possible to conveniently express this as actual move construction). So
1587	// the default copy ctor here is fine, because the base class disables the
1588	// source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op
1589	// in that case anwyay.
1590	ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;
1591
1592	~ImmediateDiagBuilder() {
1593	// If we aren't active, there is nothing to do.
1594	if (!isActive()) return;
1595
1596	// Otherwise, we need to emit the diagnostic. First clear the diagnostic
1597	// builder itself so it won't emit the diagnostic in its own destructor.
1598	//
1599	// This seems wasteful, in that as written the DiagnosticBuilder dtor will
1600	// do its own needless checks to see if the diagnostic needs to be
1601	// emitted. However, because we take care to ensure that the builder
1602	// objects never escape, a sufficiently smart compiler will be able to
1603	// eliminate that code.
1604	Clear();
1605
1606	// Dispatch to Sema to emit the diagnostic.
1607	SemaRef.EmitCurrentDiagnostic(DiagID);
1608	}
1609
1610	/// Teach operator<< to produce an object of the correct type.
1611	template <typename T>
1612	friend const ImmediateDiagBuilder &
1613	operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1614	const DiagnosticBuilder &BaseDiag = Diag;
1615	BaseDiag << Value;
1616	return Diag;
1617	}
1618
1619	// It is necessary to limit this to rvalue reference to avoid calling this
1620	// function with a bitfield lvalue argument since non-const reference to
1621	// bitfield is not allowed.
1622	template <typename T, typename = typename std::enable_if<
1623	!std::is_lvalue_reference<T>::value>::type>
1624	const ImmediateDiagBuilder &operator<<(T &&V) const {
1625	const DiagnosticBuilder &BaseDiag = *this;
1626	BaseDiag << std::move(V);
1627	return *this;
1628	}
1629	};
1630
1631	/// A generic diagnostic builder for errors which may or may not be deferred.
1632	///
1633	/// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
1634	/// which are not allowed to appear inside __device__ functions and are
1635	/// allowed to appear in __host__ __device__ functions only if the host+device
1636	/// function is never codegen'ed.
1637	///
1638	/// To handle this, we use the notion of "deferred diagnostics", where we
1639	/// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
1640	///
1641	/// This class lets you emit either a regular diagnostic, a deferred
1642	/// diagnostic, or no diagnostic at all, according to an argument you pass to
1643	/// its constructor, thus simplifying the process of creating these "maybe
1644	/// deferred" diagnostics.
1645	class SemaDiagnosticBuilder {
1646	public:
1647	enum Kind {
1648	/// Emit no diagnostics.
1649	K_Nop,
1650	/// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
1651	K_Immediate,
1652	/// Emit the diagnostic immediately, and, if it's a warning or error, also
1653	/// emit a call stack showing how this function can be reached by an a
1654	/// priori known-emitted function.
1655	K_ImmediateWithCallStack,
1656	/// Create a deferred diagnostic, which is emitted only if the function
1657	/// it's attached to is codegen'ed. Also emit a call stack as with
1658	/// K_ImmediateWithCallStack.
1659	K_Deferred
1660	};
1661
1662	SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
1663	FunctionDecl *Fn, Sema &S);
1664	SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);
1665	SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;
1666	~SemaDiagnosticBuilder();
1667
1668	bool isImmediate() const { return ImmediateDiag.hasValue(); }
1669
1670	/// Convertible to bool: True if we immediately emitted an error, false if
1671	/// we didn't emit an error or we created a deferred error.
1672	///
1673	/// Example usage:
1674	///
1675	/// if (SemaDiagnosticBuilder(...) << foo << bar)
1676	/// return ExprError();
1677	///
1678	/// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
1679	/// want to use these instead of creating a SemaDiagnosticBuilder yourself.
1680	operator bool() const { return isImmediate(); }
1681
1682	template <typename T>
1683	friend const SemaDiagnosticBuilder &
1684	operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1685	if (Diag.ImmediateDiag.hasValue())
1686	*Diag.ImmediateDiag << Value;
1687	else if (Diag.PartialDiagId.hasValue())
1688	Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1689	<< Value;
1690	return Diag;
1691	}
1692
1693	// It is necessary to limit this to rvalue reference to avoid calling this
1694	// function with a bitfield lvalue argument since non-const reference to
1695	// bitfield is not allowed.
1696	template <typename T, typename = typename std::enable_if<
1697	!std::is_lvalue_reference<T>::value>::type>
1698	const SemaDiagnosticBuilder &operator<<(T &&V) const {
1699	if (ImmediateDiag.hasValue())
1700	*ImmediateDiag << std::move(V);
1701	else if (PartialDiagId.hasValue())
1702	S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V);
1703	return *this;
1704	}
1705
1706	friend const SemaDiagnosticBuilder &
1707	operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) {
1708	if (Diag.ImmediateDiag.hasValue())
1709	PD.Emit(*Diag.ImmediateDiag);
1710	else if (Diag.PartialDiagId.hasValue())
1711	Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD;
1712	return Diag;
1713	}
1714
1715	void AddFixItHint(const FixItHint &Hint) const {
1716	if (ImmediateDiag.hasValue())
1717	ImmediateDiag->AddFixItHint(Hint);
1718	else if (PartialDiagId.hasValue())
1719	S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint);
1720	}
1721
1722	friend ExprResult ExprError(const SemaDiagnosticBuilder &) {
1723	return ExprError();
1724	}
1725	friend StmtResult StmtError(const SemaDiagnosticBuilder &) {
1726	return StmtError();
1727	}
1728	operator ExprResult() const { return ExprError(); }
1729	operator StmtResult() const { return StmtError(); }
1730	operator TypeResult() const { return TypeError(); }
1731	operator DeclResult() const { return DeclResult(true); }
1732	operator MemInitResult() const { return MemInitResult(true); }
1733
1734	private:
1735	Sema &S;
1736	SourceLocation Loc;
1737	unsigned DiagID;
1738	FunctionDecl *Fn;
1739	bool ShowCallStack;
1740
1741	// Invariant: At most one of these Optionals has a value.
1742	// FIXME: Switch these to a Variant once that exists.
1743	llvm::Optional<ImmediateDiagBuilder> ImmediateDiag;
1744	llvm::Optional<unsigned> PartialDiagId;
1745	};
1746
1747	/// Is the last error level diagnostic immediate. This is used to determined
1748	/// whether the next info diagnostic should be immediate.
1749	bool IsLastErrorImmediate = true;
1750
1751	/// Emit a diagnostic.
1752	SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID,
1753	bool DeferHint = false);
1754
1755	/// Emit a partial diagnostic.
1756	SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,
1757	bool DeferHint = false);
1758
1759	/// Build a partial diagnostic.
1760	PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1761
1762	/// Whether uncompilable error has occurred. This includes error happens
1763	/// in deferred diagnostics.
1764	bool hasUncompilableErrorOccurred() const;
1765
1766	bool findMacroSpelling(SourceLocation &loc, StringRef name);
1767
1768	/// Get a string to suggest for zero-initialization of a type.
1769	std::string
1770	getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1771	std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1772
1773	/// Calls \c Lexer::getLocForEndOfToken()
1774	SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1775
1776	/// Retrieve the module loader associated with the preprocessor.
1777	ModuleLoader &getModuleLoader() const;
1778
1779	/// Invent a new identifier for parameters of abbreviated templates.
1780	IdentifierInfo *
1781	InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
1782	unsigned Index);
1783
1784	void emitAndClearUnusedLocalTypedefWarnings();
1785
1786	private:
1787	/// Function or variable declarations to be checked for whether the deferred
1788	/// diagnostics should be emitted.
1789	SmallVector<Decl *, 4> DeclsToCheckForDeferredDiags;
1790
1791	public:
1792	// Emit all deferred diagnostics.
1793	void emitDeferredDiags();
1794
1795	enum TUFragmentKind {
1796	/// The global module fragment, between 'module;' and a module-declaration.
1797	Global,
1798	/// A normal translation unit fragment. For a non-module unit, this is the
1799	/// entire translation unit. Otherwise, it runs from the module-declaration
1800	/// to the private-module-fragment (if any) or the end of the TU (if not).
1801	Normal,
1802	/// The private module fragment, between 'module :private;' and the end of
1803	/// the translation unit.
1804	Private
1805	};
1806
1807	void ActOnStartOfTranslationUnit();
1808	void ActOnEndOfTranslationUnit();
1809	void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind);
1810
1811	void CheckDelegatingCtorCycles();
1812
1813	Scope getScopeForContext(DeclContext Ctx);
1814
1815	void PushFunctionScope();
1816	void PushBlockScope(Scope BlockScope, BlockDecl Block);
1817	sema::LambdaScopeInfo *PushLambdaScope();
1818
1819	/// This is used to inform Sema what the current TemplateParameterDepth
1820	/// is during Parsing. Currently it is used to pass on the depth
1821	/// when parsing generic lambda 'auto' parameters.
1822	void RecordParsingTemplateParameterDepth(unsigned Depth);
1823
1824	void PushCapturedRegionScope(Scope RegionScope, CapturedDecl CD,
1825	RecordDecl *RD, CapturedRegionKind K,
1826	unsigned OpenMPCaptureLevel = 0);
1827
1828	/// Custom deleter to allow FunctionScopeInfos to be kept alive for a short
1829	/// time after they've been popped.
1830	class PoppedFunctionScopeDeleter {
1831	Sema *Self;
1832
1833	public:
1834	explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {}
1835	void operator()(sema::FunctionScopeInfo *Scope) const;
1836	};
1837
1838	using PoppedFunctionScopePtr =
1839	std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1840
1841	PoppedFunctionScopePtr
1842	PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1843	const Decl *D = nullptr,
1844	QualType BlockType = QualType());
1845
1846	sema::FunctionScopeInfo *getCurFunction() const {
1847	return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1848	}
1849
1850	sema::FunctionScopeInfo *getEnclosingFunction() const;
1851
1852	void setFunctionHasBranchIntoScope();
1853	void setFunctionHasBranchProtectedScope();
1854	void setFunctionHasIndirectGoto();
1855	void setFunctionHasMustTail();
1856
1857	void PushCompoundScope(bool IsStmtExpr);
1858	void PopCompoundScope();
1859
1860	sema::CompoundScopeInfo &getCurCompoundScope() const;
1861
1862	bool hasAnyUnrecoverableErrorsInThisFunction() const;
1863
1864	/// Retrieve the current block, if any.
1865	sema::BlockScopeInfo *getCurBlock();
1866
1867	/// Get the innermost lambda enclosing the current location, if any. This
1868	/// looks through intervening non-lambda scopes such as local functions and
1869	/// blocks.
1870	sema::LambdaScopeInfo *getEnclosingLambda() const;
1871
1872	/// Retrieve the current lambda scope info, if any.
1873	/// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1874	/// lambda scope info ignoring all inner capturing scopes that are not
1875	/// lambda scopes.
1876	sema::LambdaScopeInfo *
1877	getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1878
1879	/// Retrieve the current generic lambda info, if any.
1880	sema::LambdaScopeInfo *getCurGenericLambda();
1881
1882	/// Retrieve the current captured region, if any.
1883	sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1884
1885	/// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1886	SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1887
1888	/// Called before parsing a function declarator belonging to a function
1889	/// declaration.
1890	void ActOnStartFunctionDeclarationDeclarator(Declarator &D,
1891	unsigned TemplateParameterDepth);
1892
1893	/// Called after parsing a function declarator belonging to a function
1894	/// declaration.
1895	void ActOnFinishFunctionDeclarationDeclarator(Declarator &D);
1896
1897	void ActOnComment(SourceRange Comment);
1898
1899	//===--------------------------------------------------------------------===//
1900	// Type Analysis / Processing: SemaType.cpp.
1901	//
1902
1903	QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1904	const DeclSpec *DS = nullptr);
1905	QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1906	const DeclSpec *DS = nullptr);
1907	QualType BuildPointerType(QualType T,
1908	SourceLocation Loc, DeclarationName Entity);
1909	QualType BuildReferenceType(QualType T, bool LValueRef,
1910	SourceLocation Loc, DeclarationName Entity);
1911	QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1912	Expr *ArraySize, unsigned Quals,
1913	SourceRange Brackets, DeclarationName Entity);
1914	QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1915	QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1916	SourceLocation AttrLoc);
1917	QualType BuildMatrixType(QualType T, Expr NumRows, Expr NumColumns,
1918	SourceLocation AttrLoc);
1919
1920	QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1921	SourceLocation AttrLoc);
1922
1923	/// Same as above, but constructs the AddressSpace index if not provided.
1924	QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1925	SourceLocation AttrLoc);
1926
1927	bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
1928
1929	bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1930
1931	/// Build a function type.
1932	///
1933	/// This routine checks the function type according to C++ rules and
1934	/// under the assumption that the result type and parameter types have
1935	/// just been instantiated from a template. It therefore duplicates
1936	/// some of the behavior of GetTypeForDeclarator, but in a much
1937	/// simpler form that is only suitable for this narrow use case.
1938	///
1939	/// \param T The return type of the function.
1940	///
1941	/// \param ParamTypes The parameter types of the function. This array
1942	/// will be modified to account for adjustments to the types of the
1943	/// function parameters.
1944	///
1945	/// \param Loc The location of the entity whose type involves this
1946	/// function type or, if there is no such entity, the location of the
1947	/// type that will have function type.
1948	///
1949	/// \param Entity The name of the entity that involves the function
1950	/// type, if known.
1951	///
1952	/// \param EPI Extra information about the function type. Usually this will
1953	/// be taken from an existing function with the same prototype.
1954	///
1955	/// \returns A suitable function type, if there are no errors. The
1956	/// unqualified type will always be a FunctionProtoType.
1957	/// Otherwise, returns a NULL type.
1958	QualType BuildFunctionType(QualType T,
1959	MutableArrayRef<QualType> ParamTypes,
1960	SourceLocation Loc, DeclarationName Entity,
1961	const FunctionProtoType::ExtProtoInfo &EPI);
1962
1963	QualType BuildMemberPointerType(QualType T, QualType Class,
1964	SourceLocation Loc,
1965	DeclarationName Entity);
1966	QualType BuildBlockPointerType(QualType T,
1967	SourceLocation Loc, DeclarationName Entity);
1968	QualType BuildParenType(QualType T);
1969	QualType BuildAtomicType(QualType T, SourceLocation Loc);
1970	QualType BuildReadPipeType(QualType T,
1971	SourceLocation Loc);
1972	QualType BuildWritePipeType(QualType T,
1973	SourceLocation Loc);
1974	QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc);
1975
1976	TypeSourceInfo GetTypeForDeclarator(Declarator &D, Scope S);
1977	TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
1978
1979	/// Package the given type and TSI into a ParsedType.
1980	ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
1981	DeclarationNameInfo GetNameForDeclarator(Declarator &D);
1982	DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
1983	static QualType GetTypeFromParser(ParsedType Ty,
1984	TypeSourceInfo **TInfo = nullptr);
1985	CanThrowResult canThrow(const Stmt *E);
1986	/// Determine whether the callee of a particular function call can throw.
1987	/// E, D and Loc are all optional.
1988	static CanThrowResult canCalleeThrow(Sema &S, const Expr E, const Decl D,
1989	SourceLocation Loc = SourceLocation());
1990	const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
1991	const FunctionProtoType *FPT);
1992	void UpdateExceptionSpec(FunctionDecl *FD,
1993	const FunctionProtoType::ExceptionSpecInfo &ESI);
1994