/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h

Bug Summary

File:	tools/clang/lib/Sema/TreeTransform.h
Warning:	line 4641, column 22 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplate.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn373517/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn373517=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-02-234743-9763-1 -x c++ /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp

→

1//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===//
7//
8//  This file implements semantic analysis for C++ templates.
9//===----------------------------------------------------------------------===//

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

36#include <iterator>
37using namespace clang;
38using namespace sema;

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

48namespace clang {
49/// [temp.constr.decl]p2: A template's associated constraints are
50/// defined as a single constraint-expression derived from the introduced
51/// constraint-expressions [ ... ].
52///
53/// \param Params The template parameter list and optional requires-clause.
54///
55/// \param FD The underlying templated function declaration for a function
56/// template.
57static Expr *formAssociatedConstraints(TemplateParameterList *Params,
                                     FunctionDecl *FD);
59}

61static Expr *clang::formAssociatedConstraints(TemplateParameterList *Params,
                                            FunctionDecl *FD) {
// FIXME: Concepts: collect additional introduced constraint-expressions
assert(!FD && "Cannot collect constraints from function declaration yet.")((!FD && "Cannot collect constraints from function declaration yet."
) ? static_cast<void> (0) : __assert_fail ("!FD && \"Cannot collect constraints from function declaration yet.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 64, __PRETTY_FUNCTION__));
return Params->getRequiresClause();
66}

68/// Determine whether the declaration found is acceptable as the name
69/// of a template and, if so, return that template declaration. Otherwise,
70/// returns null.
71///
72/// Note that this may return an UnresolvedUsingValueDecl if AllowDependent
73/// is true. In all other cases it will return a TemplateDecl (or null).
74NamedDecl *Sema::getAsTemplateNameDecl(NamedDecl *D,
                                     bool AllowFunctionTemplates,
                                     bool AllowDependent) {
D = D->getUnderlyingDecl();

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

  return D;
}

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

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

  return nullptr;
}

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

return nullptr;
118}

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

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

return false;
145}

147TemplateNameKind Sema::isTemplateName(Scope *S,
                                    CXXScopeSpec &SS,
                                    bool hasTemplateKeyword,
                                    const UnqualifiedId &Name,
                                    ParsedType ObjectTypePtr,
                                    bool EnteringContext,
                                    TemplateTy &TemplateResult,
                                    bool &MemberOfUnknownSpecialization) {
assert(getLangOpts().CPlusPlus && "No template names in C!")((getLangOpts().CPlusPlus && "No template names in C!"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"No template names in C!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 155, __PRETTY_FUNCTION__));

DeclarationName TName;
MemberOfUnknownSpecialization = false;

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

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

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

default:
  return TNK_Non_template;
}

QualType ObjectType = ObjectTypePtr.get();

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

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

if (R.empty())
  return TNK_Non_template;

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

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

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

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

TemplateName Template;
TemplateNameKind TemplateKind;

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

  // We'll do this lookup again later.
  R.suppressDiagnostics();
} else {
  if (!D) {
    D = getAsTemplateNameDecl(*R.begin());
    assert(D && "unambiguous result is not a template name")((D && "unambiguous result is not a template name") ?
 static_cast<void> (0) : __assert_fail ("D && \"unambiguous result is not a template name\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 248, __PRETTY_FUNCTION__));
  }

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

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

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

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

    // We'll do this lookup again later.
    R.suppressDiagnostics();
  } else {
    assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||((isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl
>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl
>(TD) || isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl
>(TD)) ? static_cast<void> (0) : __assert_fail ("isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 275, __PRETTY_FUNCTION__))
           isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||((isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl
>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl
>(TD) || isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl
>(TD)) ? static_cast<void> (0) : __assert_fail ("isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 275, __PRETTY_FUNCTION__))
           isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD))((isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl
>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl
>(TD) || isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl
>(TD)) ? static_cast<void> (0) : __assert_fail ("isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) || isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 275, __PRETTY_FUNCTION__));
    TemplateKind =
        isa<VarTemplateDecl>(TD) ? TNK_Var_template :
        isa<ConceptDecl>(TD) ? TNK_Concept_template :
        TNK_Type_template;
  }
}

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

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

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

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

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

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

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

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

345bool Sema::LookupTemplateName(LookupResult &Found,
                            Scope *S, CXXScopeSpec &SS,
                            QualType ObjectType,
                            bool EnteringContext,
                            bool &MemberOfUnknownSpecialization,
                            SourceLocation TemplateKWLoc,
                            AssumedTemplateKind *ATK) {
if (ATK)
  *ATK = AssumedTemplateKind::None;

Found.setTemplateNameLookup(true);

// Determine where to perform name lookup
MemberOfUnknownSpecialization = false;
DeclContext *LookupCtx = nullptr;
bool IsDependent = false;
if (!ObjectType.isNull()) {
  // This nested-name-specifier occurs in a member access expression, e.g.,
  // x->B::f, and we are looking into the type of the object.
  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist")((!SS.isSet() && "ObjectType and scope specifier cannot coexist"
) ? static_cast<void> (0) : __assert_fail ("!SS.isSet() && \"ObjectType and scope specifier cannot coexist\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 364, __PRETTY_FUNCTION__));
  LookupCtx = computeDeclContext(ObjectType);
  IsDependent = !LookupCtx && ObjectType->isDependentType();
  assert((IsDependent || !ObjectType->isIncompleteType() ||(((IsDependent || !ObjectType->isIncompleteType() || ObjectType
->castAs<TagType>()->isBeingDefined()) &&
 "Caller should have completed object type") ? static_cast<
void> (0) : __assert_fail ("(IsDependent || !ObjectType->isIncompleteType() || ObjectType->castAs<TagType>()->isBeingDefined()) && \"Caller should have completed object type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 369, __PRETTY_FUNCTION__))
          ObjectType->castAs<TagType>()->isBeingDefined()) &&(((IsDependent || !ObjectType->isIncompleteType() || ObjectType
->castAs<TagType>()->isBeingDefined()) &&
 "Caller should have completed object type") ? static_cast<
void> (0) : __assert_fail ("(IsDependent || !ObjectType->isIncompleteType() || ObjectType->castAs<TagType>()->isBeingDefined()) && \"Caller should have completed object type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 369, __PRETTY_FUNCTION__))
         "Caller should have completed object type")(((IsDependent || !ObjectType->isIncompleteType() || ObjectType
->castAs<TagType>()->isBeingDefined()) &&
 "Caller should have completed object type") ? static_cast<
void> (0) : __assert_fail ("(IsDependent || !ObjectType->isIncompleteType() || ObjectType->castAs<TagType>()->isBeingDefined()) && \"Caller should have completed object type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 369, __PRETTY_FUNCTION__));

  // Template names cannot appear inside an Objective-C class or object type
  // or a vector type.
  //
  // FIXME: This is wrong. For example:
  //
  //   template<typename T> using Vec = T __attribute__((ext_vector_type(4)));
  //   Vec<int> vi;
  //   vi.Vec<int>::~Vec<int>();
  //
  // ... should be accepted but we will not treat 'Vec' as a template name
  // here. The right thing to do would be to check if the name is a valid
  // vector component name, and look up a template name if not. And similarly
  // for lookups into Objective-C class and object types, where the same
  // problem can arise.
  if (ObjectType->isObjCObjectOrInterfaceType() ||
      ObjectType->isVectorType()) {
    Found.clear();
    return false;
  }
} else if (SS.isSet()) {
  // This nested-name-specifier occurs after another nested-name-specifier,
  // so long into the context associated with the prior nested-name-specifier.
  LookupCtx = computeDeclContext(SS, EnteringContext);
  IsDependent = !LookupCtx;

  // The declaration context must be complete.
  if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
    return true;
}

bool ObjectTypeSearchedInScope = false;
bool AllowFunctionTemplatesInLookup = true;
if (LookupCtx) {
  // Perform "qualified" name lookup into the declaration context we
  // computed, which is either the type of the base of a member access
  // expression or the declaration context associated with a prior
  // nested-name-specifier.
  LookupQualifiedName(Found, LookupCtx);

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

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

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

  IsDependent |= Found.wasNotFoundInCurrentInstantiation();
}

if (Found.isAmbiguous())
  return false;

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

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

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

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

  return false;
}

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

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

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

return false;
582}

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

DeclarationNameInfo NameInfo;
CXXScopeSpec SS;
LookupNameKind LookupKind;

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

// Figure out what name we looked up.
if (auto *DRE = dyn_cast<DeclRefExpr>(TemplateName.get())) {
  NameInfo = DRE->getNameInfo();
  SS.Adopt(DRE->getQualifierLoc());
  LookupKind = LookupOrdinaryName;
  Found = DRE->getFoundDecl();
} else if (auto *ME = dyn_cast<MemberExpr>(TemplateName.get())) {
  NameInfo = ME->getMemberNameInfo();
  SS.Adopt(ME->getQualifierLoc());
  LookupKind = LookupMemberName;
  LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
  Found = ME->getMemberDecl();
} else if (auto *DSDRE =
               dyn_cast<DependentScopeDeclRefExpr>(TemplateName.get())) {
  NameInfo = DSDRE->getNameInfo();
  SS.Adopt(DSDRE->getQualifierLoc());
  MissingTemplateKeyword = true;
} else if (auto *DSME =
               dyn_cast<CXXDependentScopeMemberExpr>(TemplateName.get())) {
  NameInfo = DSME->getMemberNameInfo();
  SS.Adopt(DSME->getQualifierLoc());
  MissingTemplateKeyword = true;
} else {
  llvm_unreachable("unexpected kind of potential template name")::llvm::llvm_unreachable_internal("unexpected kind of potential template name"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 621);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


748/// Determine whether we would be unable to instantiate this template (because
749/// it either has no definition, or is in the process of being instantiated).
750bool Sema::DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
                                        NamedDecl *Instantiation,
                                        bool InstantiatedFromMember,
                                        const NamedDecl *Pattern,
                                        const NamedDecl *PatternDef,
                                        TemplateSpecializationKind TSK,
                                        bool Complain /*= true*/) {
assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||((isa<TagDecl>(Instantiation) || isa<FunctionDecl>
(Instantiation) || isa<VarDecl>(Instantiation)) ? static_cast
<void> (0) : __assert_fail ("isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) || isa<VarDecl>(Instantiation)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 758, __PRETTY_FUNCTION__))
       isa<VarDecl>(Instantiation))((isa<TagDecl>(Instantiation) || isa<FunctionDecl>
(Instantiation) || isa<VarDecl>(Instantiation)) ? static_cast
<void> (0) : __assert_fail ("isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) || isa<VarDecl>(Instantiation)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 758, __PRETTY_FUNCTION__));

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

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

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

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

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

845/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
846/// that the template parameter 'PrevDecl' is being shadowed by a new
847/// declaration at location Loc. Returns true to indicate that this is
848/// an error, and false otherwise.
849void Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
assert(PrevDecl->isTemplateParameter() && "Not a template parameter")((PrevDecl->isTemplateParameter() && "Not a template parameter"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->isTemplateParameter() && \"Not a template parameter\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 850, __PRETTY_FUNCTION__));

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

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

874ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
                                           SourceLocation EllipsisLoc) const {
assert(Kind == Template &&((Kind == Template && "Only template template arguments can be pack expansions here"
) ? static_cast<void> (0) : __assert_fail ("Kind == Template && \"Only template template arguments can be pack expansions here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 877, __PRETTY_FUNCTION__))
       "Only template template arguments can be pack expansions here")((Kind == Template && "Only template template arguments can be pack expansions here"
) ? static_cast<void> (0) : __assert_fail ("Kind == Template && \"Only template template arguments can be pack expansions here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 877, __PRETTY_FUNCTION__));
assert(getAsTemplate().get().containsUnexpandedParameterPack() &&((getAsTemplate().get().containsUnexpandedParameterPack() &&
 "Template template argument pack expansion without packs") ?
 static_cast<void> (0) : __assert_fail ("getAsTemplate().get().containsUnexpandedParameterPack() && \"Template template argument pack expansion without packs\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 879, __PRETTY_FUNCTION__))
       "Template template argument pack expansion without packs")((getAsTemplate().get().containsUnexpandedParameterPack() &&
 "Template template argument pack expansion without packs") ?
 static_cast<void> (0) : __assert_fail ("getAsTemplate().get().containsUnexpandedParameterPack() && \"Template template argument pack expansion without packs\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 879, __PRETTY_FUNCTION__));
ParsedTemplateArgument Result(*this);
Result.EllipsisLoc = EllipsisLoc;
return Result;
883}

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

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

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

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

llvm_unreachable("Unhandled parsed template argument")::llvm::llvm_unreachable_internal("Unhandled parsed template argument"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 917);
918}

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

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

938/// Convert a parsed type into a parsed template argument. This is mostly
939/// trivial, except that we may have parsed a C++17 deduced class template
940/// specialization type, in which case we should form a template template
941/// argument instead of a type template argument.
942ParsedTemplateArgument Sema::ActOnTemplateTypeArgument(TypeResult ParsedType) {
TypeSourceInfo *TInfo;
QualType T = GetTypeFromParser(ParsedType.get(), &TInfo);
if (T.isNull())
  return ParsedTemplateArgument();
assert(TInfo && "template argument with no location")((TInfo && "template argument with no location") ? static_cast
<void> (0) : __assert_fail ("TInfo && \"template argument with no location\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 947, __PRETTY_FUNCTION__));

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

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

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

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

988/// ActOnTypeParameter - Called when a C++ template type parameter
989/// (e.g., "typename T") has been parsed. Typename specifies whether
990/// the keyword "typename" was used to declare the type parameter
991/// (otherwise, "class" was used), and KeyLoc is the location of the
992/// "class" or "typename" keyword. ParamName is the name of the
993/// parameter (NULL indicates an unnamed template parameter) and
994/// ParamNameLoc is the location of the parameter name (if any).
995/// If the type parameter has a default argument, it will be added
996/// later via ActOnTypeParameterDefault.
997NamedDecl *Sema::ActOnTypeParameter(Scope *S, bool Typename,
                             SourceLocation EllipsisLoc,
                             SourceLocation KeyLoc,
                             IdentifierInfo *ParamName,
                             SourceLocation ParamNameLoc,
                             unsigned Depth, unsigned Position,
                             SourceLocation EqualLoc,
                             ParsedType DefaultArg) {
assert(S->isTemplateParamScope() &&((S->isTemplateParamScope() && "Template type parameter not in template parameter scope!"
) ? static_cast<void> (0) : __assert_fail ("S->isTemplateParamScope() && \"Template type parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1006, __PRETTY_FUNCTION__))
       "Template type parameter not in template parameter scope!")((S->isTemplateParamScope() && "Template type parameter not in template parameter scope!"
) ? static_cast<void> (0) : __assert_fail ("S->isTemplateParamScope() && \"Template type parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1006, __PRETTY_FUNCTION__));

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

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

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

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

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

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

  assert(DefaultTInfo && "expected source information for type")((DefaultTInfo && "expected source information for type"
) ? static_cast<void> (0) : __assert_fail ("DefaultTInfo && \"expected source information for type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1039, __PRETTY_FUNCTION__));

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

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

  Param->setDefaultArgument(DefaultTInfo);
}

return Param;
1056}

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

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

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

// C++ [temp.param]p4:
//
// A non-type template-parameter shall have one of the following
// (optionally cv-qualified) types:
//
//       -- integral or enumeration type,
if (T->isIntegralOrEnumerationType() ||
    //   -- pointer to object or pointer to function,
    T->isPointerType() ||
    //   -- reference to object or reference to function,
    T->isReferenceType() ||
    //   -- pointer to member,
    T->isMemberPointerType() ||
    //   -- std::nullptr_t.
    T->isNullPtrType() ||
    // If T is a dependent type, we can't do the check now, so we
    // assume that it is well-formed.
    T->isDependentType() ||
    // Allow use of auto in template parameter declarations.
    T->isUndeducedType()) {
  // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
  // are ignored when determining its type.
  return T.getUnqualifiedType();
}

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

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

return QualType();
1124}

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

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

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

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

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

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

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

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

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

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

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

CheckValidDeclSpecifiers();

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

assert(S->isTemplateParamScope() &&((S->isTemplateParamScope() && "Non-type template parameter not in template parameter scope!"
) ? static_cast<void> (0) : __assert_fail ("S->isTemplateParamScope() && \"Non-type template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1194, __PRETTY_FUNCTION__))
       "Non-type template parameter not in template parameter scope!")((S->isTemplateParamScope() && "Non-type template parameter not in template parameter scope!"
) ? static_cast<void> (0) : __assert_fail ("S->isTemplateParamScope() && \"Non-type template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1194, __PRETTY_FUNCTION__));
bool Invalid = false;

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

CheckFunctionOrTemplateParamDeclarator(S, D);

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

if (Invalid)
  Param->setInvalidDecl();

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

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

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

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

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

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

  Param->setDefaultArgument(Default);
}

return Param;
1256}

1258/// ActOnTemplateTemplateParameter - Called when a C++ template template
1259/// parameter (e.g. T in template <template \<typename> class T> class array)
1260/// has been parsed. S is the current scope.
1261NamedDecl *Sema::ActOnTemplateTemplateParameter(Scope* S,
                                         SourceLocation TmpLoc,
                                         TemplateParameterList *Params,
                                         SourceLocation EllipsisLoc,
                                         IdentifierInfo *Name,
                                         SourceLocation NameLoc,
                                         unsigned Depth,
                                         unsigned Position,
                                         SourceLocation EqualLoc,
                                         ParsedTemplateArgument Default) {
assert(S->isTemplateParamScope() &&((S->isTemplateParamScope() && "Template template parameter not in template parameter scope!"
) ? static_cast<void> (0) : __assert_fail ("S->isTemplateParamScope() && \"Template template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1272, __PRETTY_FUNCTION__))
       "Template template parameter not in template parameter scope!")((S->isTemplateParamScope() && "Template template parameter not in template parameter scope!"
) ? static_cast<void> (0) : __assert_fail ("S->isTemplateParamScope() && \"Template template parameter not in template parameter scope!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1272, __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

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

  Param->setDefaultArgument(Context, DefaultArg);
}

return Param;
1336}

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

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

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

1364DeclResult Sema::CheckClassTemplate(
  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
  CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
  const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
  SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
  TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {
assert(TemplateParams && TemplateParams->size() > 0 &&((TemplateParams && TemplateParams->size() > 0 &&
 "No template parameters") ? static_cast<void> (0) : __assert_fail
 ("TemplateParams && TemplateParams->size() > 0 && \"No template parameters\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1372, __PRETTY_FUNCTION__))
       "No template parameters")((TemplateParams && TemplateParams->size() > 0 &&
 "No template parameters") ? static_cast<void> (0) : __assert_fail
 ("TemplateParams && TemplateParams->size() > 0 && \"No template parameters\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1372, __PRETTY_FUNCTION__));
assert(TUK != TUK_Reference && "Can only declare or define class templates")((TUK != TUK_Reference && "Can only declare or define class templates"
) ? static_cast<void> (0) : __assert_fail ("TUK != TUK_Reference && \"Can only declare or define class templates\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1373, __PRETTY_FUNCTION__));
bool Invalid = false;

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

TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum && "can't build template of enumerated type")((Kind != TTK_Enum && "can't build template of enumerated type"
) ? static_cast<void> (0) : __assert_fail ("Kind != TTK_Enum && \"can't build template of enumerated type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1381, __PRETTY_FUNCTION__));

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

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

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

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

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

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

  LookupName(Previous, S);
}

if (Previous.isAmbiguous())
  return true;

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

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

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

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

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

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

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

      if (Previous.isAmbiguous())
        return true;

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

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

// TODO Memory management; associated constraints are not always stored.
Expr *const CurAC = formAssociatedConstraints(TemplateParams, nullptr);

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

  // Check for matching associated constraints on redeclarations.
  const Expr *const PrevAC = PrevClassTemplate->getAssociatedConstraints();
  const bool RedeclACMismatch = [&] {
    if (!(CurAC || PrevAC))
      return false; // Nothing to check; no mismatch.
    if (CurAC && PrevAC) {
      llvm::FoldingSetNodeID CurACInfo, PrevACInfo;
      CurAC->Profile(CurACInfo, Context, /*Canonical=*/true);
      PrevAC->Profile(PrevACInfo, Context, /*Canonical=*/true);
      if (CurACInfo == PrevACInfo)
        return false; // All good; no mismatch.
    }
    return true;
  }();

  if (RedeclACMismatch) {
    Diag(CurAC ? CurAC->getBeginLoc() : NameLoc,
         diag::err_template_different_associated_constraints);
    Diag(PrevAC ? PrevAC->getBeginLoc() : PrevClassTemplate->getLocation(),
         diag::note_template_prev_declaration)
        << /*declaration*/ 0;
    return true;
  }

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

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

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

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

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

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

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

// Attach the associated constraints when the declaration will not be part of
// a decl chain.
Expr *const ACtoAttach =
    PrevClassTemplate && ShouldAddRedecl ? nullptr : CurAC;

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

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

NewClass->setDescribedClassTemplate(NewTemplate);

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

// Build the type for the class template declaration now.
QualType T = NewTemplate->getInjectedClassNameSpecialization();
T = Context.getInjectedClassNameType(NewClass, T);
assert(T->isDependentType() && "Class template type is not dependent?")((T->isDependentType() && "Class template type is not dependent?"
) ? static_cast<void> (0) : __assert_fail ("T->isDependentType() && \"Class template type is not dependent?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1692, __PRETTY_FUNCTION__));
(void)T;

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

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

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

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

ProcessDeclAttributeList(S, NewClass, Attr);

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

AddPushedVisibilityAttribute(NewClass);
inferGslOwnerPointerAttribute(NewClass);

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

  NewTemplate->setObjectOfFriendDecl();

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

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

if (PrevClassTemplate)
  CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);

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

ActOnDocumentableDecl(NewTemplate);

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

return NewTemplate;
1763}

1765namespace {
1766/// Tree transform to "extract" a transformed type from a class template's
1767/// constructor to a deduction guide.
1768class ExtractTypeForDeductionGuide
: public TreeTransform<ExtractTypeForDeductionGuide> {
1770public:
typedef TreeTransform<ExtractTypeForDeductionGuide> Base;
ExtractTypeForDeductionGuide(Sema &SemaRef) : Base(SemaRef) {}

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

QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
  return TransformType(
1
Calling 'TreeTransform::TransformType'→
      TLB,
      TL.getTypedefNameDecl()->getTypeSourceInfo()->getTypeLoc());
}
1781};

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

Sema &SemaRef;
ClassTemplateDecl *Template;

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

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

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

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

  LocalInstantiationScope Scope(SemaRef);

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

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

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

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

  FunctionProtoTypeLoc FPTL = CD->getTypeSourceInfo()->getTypeLoc()
                                 .getAsAdjusted<FunctionProtoTypeLoc>();
  assert(FPTL && "no prototype for constructor declaration")((FPTL && "no prototype for constructor declaration")
 ? static_cast<void> (0) : __assert_fail ("FPTL && \"no prototype for constructor declaration\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1857, __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

1903private:
/// Transform a constructor template parameter into a deduction guide template
/// parameter, rebuilding any internal references to earlier parameters and
/// renumbering as we go.
NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
                                      MultiLevelTemplateArgumentList &Args) {
  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
    // TemplateTypeParmDecl's index cannot be changed after creation, so
    // substitute it directly.
    auto *NewTTP = TemplateTypeParmDecl::Create(
        SemaRef.Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
        /*Depth*/ 0, Depth1IndexAdjustment + TTP->getIndex(),
        TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
        TTP->isParameterPack());
    if (TTP->hasDefaultArgument()) {
      TypeSourceInfo *InstantiatedDefaultArg =
          SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
                            TTP->getDefaultArgumentLoc(), TTP->getDeclName());
      if (InstantiatedDefaultArg)
        NewTTP->setDefaultArgument(InstantiatedDefaultArg);
    }
    SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
                                                         NewTTP);
    return NewTTP;
  }

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

  return transformTemplateParameterImpl(
      cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
}
template<typename TemplateParmDecl>
TemplateParmDecl *
transformTemplateParameterImpl(TemplateParmDecl *OldParam,
                               MultiLevelTemplateArgumentList &Args) {
  // Ask the template instantiator to do the heavy lifting for us, then adjust
  // the index of the parameter once it's done.
  auto *NewParam =
      cast_or_null<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
  assert(NewParam->getDepth() == 0 && "unexpected template param depth")((NewParam->getDepth() == 0 && "unexpected template param depth"
) ? static_cast<void> (0) : __assert_fail ("NewParam->getDepth() == 0 && \"unexpected template param depth\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 1943, __PRETTY_FUNCTION__));
  NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
  return NewParam;
}

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

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

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

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

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

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

  return Result;
}

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

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

  // Resolving a wording defect, we also inherit default arguments from the
  // constructor.
  ExprResult NewDefArg;
  if (OldParam->hasDefaultArg()) {
    NewDefArg = SemaRef.SubstExpr(OldParam->getDefaultArg(), Args);
    if (NewDefArg.isInvalid())
      return nullptr;
  }

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

NamedDecl *buildDeductionGuide(TemplateParameterList *TemplateParams,
                               ExplicitSpecifier ES, TypeSourceInfo *TInfo,
                               SourceLocation LocStart, SourceLocation Loc,
                               SourceLocation LocEnd) {
  DeclarationNameInfo Name(DeductionGuideName, Loc);
  ArrayRef<ParmVarDecl *> Params =
      TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();

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

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

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

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

  DC->addDecl(GuideTemplate);
  return GuideTemplate;
}
2080};
2081}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

llvm_unreachable("Invalid TemplateParamListContext!")::llvm::llvm_unreachable_internal("Invalid TemplateParamListContext!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2210);
2211}

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

TemplateParameterList *Params = TTP->getTemplateParameters();
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  NamedDecl *P = Params->getParam(I);
  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
    if (!NTTP->isParameterPack() &&
        S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
                                          NTTP->getTypeSourceInfo(),
                                    Sema::UPPC_NonTypeTemplateParameterType))
      return true;

    continue;
  }

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

return false;
2242}

2244/// Checks the validity of a template parameter list, possibly
2245/// considering the template parameter list from a previous
2246/// declaration.
2247///
2248/// If an "old" template parameter list is provided, it must be
2249/// equivalent (per TemplateParameterListsAreEqual) to the "new"
2250/// template parameter list.
2251///
2252/// \param NewParams Template parameter list for a new template
2253/// declaration. This template parameter list will be updated with any
2254/// default arguments that are carried through from the previous
2255/// template parameter list.
2256///
2257/// \param OldParams If provided, template parameter list from a
2258/// previous declaration of the same template. Default template
2259/// arguments will be merged from the old template parameter list to
2260/// the new template parameter list.
2261///
2262/// \param TPC Describes the context in which we are checking the given
2263/// template parameter list.
2264///
2265/// \param SkipBody If we might have already made a prior merged definition
2266/// of this template visible, the corresponding body-skipping information.
2267/// Default argument redefinition is not an error when skipping such a body,
2268/// because (under the ODR) we can assume the default arguments are the same
2269/// as the prior merged definition.
2270///
2271/// \returns true if an error occurred, false otherwise.
2272bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
                                    TemplateParameterList *OldParams,
                                    TemplateParamListContext TPC,
                                    SkipBodyInfo *SkipBody) {
bool Invalid = false;

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

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

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

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

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

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

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

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

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

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

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

    // Merge default arguments for template template parameters
    TemplateTemplateParmDecl *OldTemplateParm
      = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
    if (NewTemplateParm->isParameterPack()) {
      assert(!NewTemplateParm->hasDefaultArgument() &&((!NewTemplateParm->hasDefaultArgument() && "Parameter packs can't have a default argument!"
) ? static_cast<void> (0) : __assert_fail ("!NewTemplateParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2409, __PRETTY_FUNCTION__))
             "Parameter packs can't have a default argument!")((!NewTemplateParm->hasDefaultArgument() && "Parameter packs can't have a default argument!"
) ? static_cast<void> (0) : __assert_fail ("!NewTemplateParm->hasDefaultArgument() && \"Parameter packs can't have a default argument!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 2409, __PRETTY_FUNCTION__));
      if (!NewTemplateParm->isPackExpansion())
        SawParameterPack = true;
    } else if (OldTemplateParm &&
               hasVisibleDefaultArgument(OldTemplateParm) &&
               NewTemplateParm->hasDefaultArgument() &&
               (!SkipBody || !SkipBody->ShouldSkip)) {
      OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
      NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
      SawDefaultArgument = true;
      RedundantDefaultArg = true;
      PreviousDefaultArgLoc = NewDefaultLoc;
    } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
      // Merge the default argument from the old declaration to the
      // new declaration.
      NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
      PreviousDefaultArgLoc
        = OldTemplateParm->getDefaultArgument().getLocation();
    } else if (NewTemplateParm->hasDefaultArgument()) {
      SawDefaultArgument = true;
      PreviousDefaultArgLoc
        = NewTemplateParm->getDefaultArgument().getLocation();
    } else if (SawDefaultArgument)
      MissingDefaultArg = true;
  }

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

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

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

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

return Invalid;
2489}

2491namespace {

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

unsigned Depth;

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

bool Match;
SourceLocation MatchLoc;

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

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

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

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

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

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

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

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

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

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

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

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

2593/// Determines whether a given type depends on the given parameter
2594/// list.
2595static bool
2596DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) {
DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
Checker.TraverseType(T);
return Checker.Match;
2600}

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

  NNSLoc = NNSLoc.getPrefix();
}

return SourceRange();
2619}

2621/// Match the given template parameter lists to the given scope
2622/// specifier, returning the template parameter list that applies to the
2623/// name.
2624///
2625/// \param DeclStartLoc the start of the declaration that has a scope
2626/// specifier or a template parameter list.
2627///
2628/// \param DeclLoc The location of the declaration itself.
2629///
2630/// \param SS the scope specifier that will be matched to the given template
2631/// parameter lists. This scope specifier precedes a qualified name that is
2632/// being declared.
2633///
2634/// \param TemplateId The template-id following the scope specifier, if there
2635/// is one. Used to check for a missing 'template<>'.
2636///
2637/// \param ParamLists the template parameter lists, from the outermost to the
2638/// innermost template parameter lists.
2639///
2640/// \param IsFriend Whether to apply the slightly different rules for
2641/// matching template parameters to scope specifiers in friend
2642/// declarations.
2643///
2644/// \param IsMemberSpecialization will be set true if the scope specifier
2645/// denotes a fully-specialized type, and therefore this is a declaration of
2646/// a member specialization.
2647///
2648/// \returns the template parameter list, if any, that corresponds to the
2649/// name that is preceded by the scope specifier @p SS. This template
2650/// parameter list may have template parameters (if we're declaring a
2651/// template) or may have no template parameters (if we're declaring a
2652/// template specialization), or may be NULL (if what we're declaring isn't
2653/// itself a template).
2654TemplateParameterList *Sema::MatchTemplateParametersToScopeSpecifier(
  SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
  TemplateIdAnnotation *TemplateId,
  ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
  bool &IsMemberSpecialization, bool &Invalid) {
IsMemberSpecialization = false;
Invalid = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

  return false;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    continue;
  }

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

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

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

      ++ParamIdx;
      continue;
    }

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

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

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

  return nullptr;
}

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

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

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

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

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

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

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

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

  return;
}
3032}

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

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

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

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

case BTK__type_pack_element:
  // Specializations of
  //    __type_pack_element<Index, T_1, ..., T_N>
  // are treated like T_Index.
  assert(Converted.size() == 2 &&((Converted.size() == 2 && "__type_pack_element should be given an index and a parameter pack"
) ? static_cast<void> (0) : __assert_fail ("Converted.size() == 2 && \"__type_pack_element should be given an index and a parameter pack\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3086, __PRETTY_FUNCTION__))
    "__type_pack_element should be given an index and a parameter pack")((Converted.size() == 2 && "__type_pack_element should be given an index and a parameter pack"
) ? static_cast<void> (0) : __assert_fail ("Converted.size() == 2 && \"__type_pack_element should be given an index and a parameter pack\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3086, __PRETTY_FUNCTION__));

  // If the Index is out of bounds, the program is ill-formed.
  TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
  llvm::APSInt Index = IndexArg.getAsIntegral();
  assert(Index >= 0 && "the index used with __type_pack_element should be of "((Index >= 0 && "the index used with __type_pack_element should be of "
 "type std::size_t, and hence be non-negative") ? static_cast
<void> (0) : __assert_fail ("Index >= 0 && \"the index used with __type_pack_element should be of \" \"type std::size_t, and hence be non-negative\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3092, __PRETTY_FUNCTION__))
                       "type std::size_t, and hence be non-negative")((Index >= 0 && "the index used with __type_pack_element should be of "
 "type std::size_t, and hence be non-negative") ? static_cast
<void> (0) : __assert_fail ("Index >= 0 && \"the index used with __type_pack_element should be of \" \"type std::size_t, and hence be non-negative\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3092, __PRETTY_FUNCTION__));
  if (Index >= Ts.pack_size()) {
    SemaRef.Diag(TemplateArgs[0].getLocation(),
                 diag::err_type_pack_element_out_of_bounds);
    return QualType();
  }

  // We simply return the type at index `Index`.
  auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
  return Nth->getAsType();
}
llvm_unreachable("unexpected BuiltinTemplateDecl!")::llvm::llvm_unreachable_internal("unexpected BuiltinTemplateDecl!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3103);
3104}

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

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

  return;
}

Terms.push_back(Clause);
3129}

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

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

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

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

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

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

return Cond;
3161}

3163namespace {

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

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

3191private:
const PrintingPolicy Policy;
3193};

3195} // end anonymous namespace

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

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

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

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

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

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

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

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

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

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

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

QualType CanonType;

bool InstantiationDependent = false;
if (TypeAliasTemplateDecl *AliasTemplate =
        dyn_cast<TypeAliasTemplateDecl>(Template)) {
  // Find the canonical type for this type alias template specialization.
  TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
  if (Pattern->isInvalidDecl())
    return QualType();

  TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
                                         Converted);

  // Only substitute for the innermost template argument list.
  MultiLevelTemplateArgumentList TemplateArgLists;
  TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
  unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
  for (unsigned I = 0; I < Depth; ++I)
    TemplateArgLists.addOuterTemplateArguments(None);

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

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

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

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

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

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

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

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

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

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

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

  if (Decl->getSpecializationKind() == TSK_Undeclared) {
    MultiLevelTemplateArgumentList TemplateArgLists;
    TemplateArgLists.addOuterTemplateArguments(Converted);
    InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
                            Decl);
  }

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

  CanonType = Context.getTypeDeclType(Decl);
  assert(isa<RecordType>(CanonType) &&((isa<RecordType>(CanonType) && "type of non-dependent specialization is not a RecordType"
) ? static_cast<void> (0) : __assert_fail ("isa<RecordType>(CanonType) && \"type of non-dependent specialization is not a RecordType\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3423, __PRETTY_FUNCTION__))
         "type of non-dependent specialization is not a RecordType")((isa<RecordType>(CanonType) && "type of non-dependent specialization is not a RecordType"
) ? static_cast<void> (0) : __assert_fail ("isa<RecordType>(CanonType) && \"type of non-dependent specialization is not a RecordType\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3423, __PRETTY_FUNCTION__));
} else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
  CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
                                         TemplateArgs);
}

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

3435void Sema::ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &ParsedName,
                                         TemplateNameKind &TNK,
                                         SourceLocation NameLoc,
                                         IdentifierInfo *&II) {
assert(TNK == TNK_Undeclared_template && "not an undeclared template name")((TNK == TNK_Undeclared_template && "not an undeclared template name"
) ? static_cast<void> (0) : __assert_fail ("TNK == TNK_Undeclared_template && \"not an undeclared template name\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3439, __PRETTY_FUNCTION__));

TemplateName Name = ParsedName.get();
auto *ATN = Name.getAsAssumedTemplateName();
assert(ATN && "not an assumed template name")((ATN && "not an assumed template name") ? static_cast
<void> (0) : __assert_fail ("ATN && \"not an assumed template name\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3443, __PRETTY_FUNCTION__));
II = ATN->getDeclName().getAsIdentifierInfo();

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

3453bool Sema::resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
                                          SourceLocation NameLoc,
                                          bool Diagnose) {
// We assumed this undeclared identifier to be an (ADL-only) function
// template name, but it was used in a context where a type was required.
// Try to typo-correct it now.
AssumedTemplateStorage *ATN = Name.getAsAssumedTemplateName();
assert(ATN && "not an assumed template name")((ATN && "not an assumed template name") ? static_cast
<void> (0) : __assert_fail ("ATN && \"not an assumed template name\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3460, __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3592TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
                                      TypeSpecifierType TagSpec,
                                      SourceLocation TagLoc,
                                      CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      TemplateTy TemplateD,
                                      SourceLocation TemplateLoc,
                                      SourceLocation LAngleLoc,
                                      ASTTemplateArgsPtr TemplateArgsIn,
                                      SourceLocation RAngleLoc) {
TemplateName Template = TemplateD.get();

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

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

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

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

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

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

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

  IdentifierInfo *Id = D->getIdentifier();
  assert(Id && "templated class must have an identifier")((Id && "templated class must have an identifier") ? static_cast
<void> (0) : __assert_fail ("Id && \"templated class must have an identifier\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3654, __PRETTY_FUNCTION__));

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

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

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

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

3690static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);

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

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

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

case TemplateArgument::Template:
  const TemplateTemplateParmDecl *TTP =
      dyn_cast_or_null<TemplateTemplateParmDecl>(
          Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl());
  return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
}
llvm_unreachable("unexpected kind of template argument")::llvm::llvm_unreachable_internal("unexpected kind of template argument"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3726);
3727}

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

unsigned Depth = Params->getDepth();

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

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

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

return true;
3753}

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

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

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

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

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

S.Diag(Template->getLocation(), diag::note_template_decl_here);
3794}

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


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

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

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

3844void Sema::CheckTemplatePartialSpecialization(
  ClassTemplatePartialSpecializationDecl *Partial) {
checkTemplatePartialSpecialization(*this, Partial);
3847}

3849void Sema::CheckTemplatePartialSpecialization(
  VarTemplatePartialSpecializationDecl *Partial) {
checkTemplatePartialSpecialization(*this, Partial);
3852}

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

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

3877DeclResult Sema::ActOnVarTemplateSpecialization(
  Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
  TemplateParameterList *TemplateParams, StorageClass SC,
  bool IsPartialSpecialization) {
// D must be variable template id.
assert(D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&((D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&
 "Variable template specialization is declared with a template it."
) ? static_cast<void> (0) : __assert_fail ("D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId && \"Variable template specialization is declared with a template it.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3883, __PRETTY_FUNCTION__))
       "Variable template specialization is declared with a template it.")((D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&
 "Variable template specialization is declared with a template it."
) ? static_cast<void> (0) : __assert_fail ("D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId && \"Variable template specialization is declared with a template it.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 3883, __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

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

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

if (IsPartialSpecialization)
  // FIXME: Template parameter list matters too
  PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
else
  PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);

VarTemplateSpecializationDecl *Specialization = nullptr;

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

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

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

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

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

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

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

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

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

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

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

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

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

return Specialization;
4069}

4071namespace {
4072/// A partial specialization whose template arguments have matched
4073/// a given template-id.
4074struct PartialSpecMatchResult {
VarTemplatePartialSpecializationDecl *Partial;
TemplateArgumentList *Args;
4077};
4078} // end anonymous namespace

4080DeclResult
4081Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
                       SourceLocation TemplateNameLoc,
                       const TemplateArgumentListInfo &TemplateArgs) {
assert(Template && "A variable template id without template?")((Template && "A variable template id without template?"
) ? static_cast<void> (0) : __assert_fail ("Template && \"A variable template id without template?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4084, __PRETTY_FUNCTION__));

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

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

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

// 1. Attempt to find the closest partial specialization that this
// specializes, if any.
// If any of the template arguments is dependent, then this is probably
// a placeholder for an incomplete declarative context; which must be
// complete by instantiation time. Thus, do not search through the partial
// specializations yet.
// TODO: Unify with InstantiateClassTemplateSpecialization()?
//       Perhaps better after unification of DeduceTemplateArguments() and
//       getMoreSpecializedPartialSpecialization().
bool InstantiationDependent = false;
if (!TemplateSpecializationType::anyDependentTemplateArguments(
        TemplateArgs, InstantiationDependent)) {

  SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
  Template->getPartialSpecializations(PartialSpecs);

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

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

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

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

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

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

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

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

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

checkSpecializationVisibility(TemplateNameLoc, Decl);

assert(Decl && "No variable template specialization?")((Decl && "No variable template specialization?") ? static_cast
<void> (0) : __assert_fail ("Decl && \"No variable template specialization?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4231, __PRETTY_FUNCTION__));
return Decl;
4233}

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

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

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

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

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

4266ExprResult
4267Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
                           const DeclarationNameInfo &NameInfo,
                           ConceptDecl *Template,
                           SourceLocation TemplateLoc,
                           const TemplateArgumentListInfo *TemplateArgs) {
// TODO: Do concept specialization here.
Diag(NameInfo.getBeginLoc(), diag::err_concept_not_implemented) <<
  "concept specialization";
return ExprError();
4276}

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

// These should be filtered out by our callers.
assert(!R.isAmbiguous() && "ambiguous lookup when building templateid")((!R.isAmbiguous() && "ambiguous lookup when building templateid"
) ? static_cast<void> (0) : __assert_fail ("!R.isAmbiguous() && \"ambiguous lookup when building templateid\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4294, __PRETTY_FUNCTION__));

// Non-function templates require a template argument list.
if (auto *TD = R.getAsSingle<TemplateDecl>()) {
  if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
    diagnoseMissingTemplateArguments(TemplateName(TD), R.getNameLoc());
    return ExprError();
  }
}

auto AnyDependentArguments = [&]() -> bool {
  bool InstantiationDependent;
  return TemplateArgs &&
         TemplateSpecializationType::anyDependentTemplateArguments(
             *TemplateArgs, InstantiationDependent);
};

// In C++1y, check variable template ids.
if (R.getAsSingle<VarTemplateDecl>() && !AnyDependentArguments()) {
  return CheckVarTemplateId(SS, R.getLookupNameInfo(),
                            R.getAsSingle<VarTemplateDecl>(),
                            TemplateKWLoc, TemplateArgs);
}

if (R.getAsSingle<ConceptDecl>() && !AnyDependentArguments()) {
  return CheckConceptTemplateId(SS, R.getLookupNameInfo(),
                                R.getAsSingle<ConceptDecl>(),
                                TemplateKWLoc, TemplateArgs);
}

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

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

return ULE;
4336}

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

assert(TemplateArgs || TemplateKWLoc.isValid())((TemplateArgs || TemplateKWLoc.isValid()) ? static_cast<void
> (0) : __assert_fail ("TemplateArgs || TemplateKWLoc.isValid()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4345, __PRETTY_FUNCTION__));
DeclContext *DC;
if (!(DC = computeDeclContext(SS, false)) ||
    DC->isDependentContext() ||
    RequireCompleteDeclContext(SS, DC))
  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);

bool MemberOfUnknownSpecialization;
LookupResult R(*this, NameInfo, LookupOrdinaryName);
if (LookupTemplateName(R, (Scope *)nullptr, SS, QualType(),
                       /*Entering*/false, MemberOfUnknownSpecialization,
                       TemplateKWLoc))
  return ExprError();

if (R.isAmbiguous())
  return ExprError();

if (R.empty()) {
  Diag(NameInfo.getLoc(), diag::err_no_member)
    << NameInfo.getName() << DC << SS.getRange();
  return ExprError();
}

if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
    << SS.getScopeRep()
    << NameInfo.getName().getAsString() << SS.getRange();
  Diag(Temp->getLocation(), diag::note_referenced_class_template);
  return ExprError();
}

return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
4377}

4379/// Form a dependent template name.
4380///
4381/// This action forms a dependent template name given the template
4382/// name and its (presumably dependent) scope specifier. For
4383/// example, given "MetaFun::template apply", the scope specifier \p
4384/// SS will be "MetaFun::", \p TemplateKWLoc contains the location
4385/// of the "template" keyword, and "apply" is the \p Name.
4386TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
                                                CXXScopeSpec &SS,
                                                SourceLocation TemplateKWLoc,
                                                const UnqualifiedId &Name,
                                                ParsedType ObjectType,
                                                bool EnteringContext,
                                                TemplateTy &Result,
                                                bool AllowInjectedClassName) {
if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TemplateKWLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_template_outside_of_template :
         diag::ext_template_outside_of_template)
    << FixItHint::CreateRemoval(TemplateKWLoc);

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

NestedNameSpecifier *Qualifier = SS.getScopeRep();

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

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

case UnqualifiedIdKind::IK_LiteralOperatorId:
  llvm_unreachable("literal operator id cannot have a dependent scope")::llvm::llvm_unreachable_internal("literal operator id cannot have a dependent scope"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4481);

default:
  break;
}

Diag(Name.getBeginLoc(), diag::err_template_kw_refers_to_non_template)
    << GetNameFromUnqualifiedId(Name).getName() << Name.getSourceRange()
    << TemplateKWLoc;
return TNK_Non_template;
4491}

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

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

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

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

    if (Result.getAsSingle<TypeDecl>() ||
        Result.getResultKind() ==
            LookupResult::NotFoundInCurrentInstantiation) {
      // Suggest that the user add 'typename' before the NNS.
      SourceLocation Loc = AL.getSourceRange().getBegin();
      Diag(Loc, getLangOpts().MSVCCompat
                    ? diag::ext_ms_template_type_arg_missing_typename
                    : diag::err_template_arg_must_be_type_suggest)
          << FixItHint::CreateInsertion(Loc, "typename ");
      Diag(Param->getLocation(), diag::note_template_param_here);

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

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

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

  return true;
}
}

if (CheckTemplateArgument(Param, TSI))
  return true;

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

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

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

4608/// Substitute template arguments into the default template argument for
4609/// the given template type parameter.
4610///
4611/// \param SemaRef the semantic analysis object for which we are performing
4612/// the substitution.
4613///
4614/// \param Template the template that we are synthesizing template arguments
4615/// for.
4616///
4617/// \param TemplateLoc the location of the template name that started the
4618/// template-id we are checking.
4619///
4620/// \param RAngleLoc the location of the right angle bracket ('>') that
4621/// terminates the template-id.
4622///
4623/// \param Param the template template parameter whose default we are
4624/// substituting into.
4625///
4626/// \param Converted the list of template arguments provided for template
4627/// parameters that precede \p Param in the template parameter list.
4628/// \returns the substituted template argument, or NULL if an error occurred.
4629static TypeSourceInfo *
4630SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           TemplateTypeParmDecl *Param,
                           SmallVectorImpl<TemplateArgument> &Converted) {
TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();

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

  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

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

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

return ArgType;
4662}

4664/// Substitute template arguments into the default template argument for
4665/// the given non-type template parameter.
4666///
4667/// \param SemaRef the semantic analysis object for which we are performing
4668/// the substitution.
4669///
4670/// \param Template the template that we are synthesizing template arguments
4671/// for.
4672///
4673/// \param TemplateLoc the location of the template name that started the
4674/// template-id we are checking.
4675///
4676/// \param RAngleLoc the location of the right angle bracket ('>') that
4677/// terminates the template-id.
4678///
4679/// \param Param the non-type template parameter whose default we are
4680/// substituting into.
4681///
4682/// \param Converted the list of template arguments provided for template
4683/// parameters that precede \p Param in the template parameter list.
4684///
4685/// \returns the substituted template argument, or NULL if an error occurred.
4686static ExprResult
4687SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           NonTypeTemplateParmDecl *Param,
                      SmallVectorImpl<TemplateArgument> &Converted) {
Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
                                 Param, Template, Converted,
                                 SourceRange(TemplateLoc, RAngleLoc));
if (Inst.isInvalid())
  return ExprError();

TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

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

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

4713/// Substitute template arguments into the default template argument for
4714/// the given template template parameter.
4715///
4716/// \param SemaRef the semantic analysis object for which we are performing
4717/// the substitution.
4718///
4719/// \param Template the template that we are synthesizing template arguments
4720/// for.
4721///
4722/// \param TemplateLoc the location of the template name that started the
4723/// template-id we are checking.
4724///
4725/// \param RAngleLoc the location of the right angle bracket ('>') that
4726/// terminates the template-id.
4727///
4728/// \param Param the template template parameter whose default we are
4729/// substituting into.
4730///
4731/// \param Converted the list of template arguments provided for template
4732/// parameters that precede \p Param in the template parameter list.
4733///
4734/// \param QualifierLoc Will be set to the nested-name-specifier (with
4735/// source-location information) that precedes the template name.
4736///
4737/// \returns the substituted template argument, or NULL if an error occurred.
4738static TemplateName
4739SubstDefaultTemplateArgument(Sema &SemaRef,
                           TemplateDecl *Template,
                           SourceLocation TemplateLoc,
                           SourceLocation RAngleLoc,
                           TemplateTemplateParmDecl *Param,
                     SmallVectorImpl<TemplateArgument> &Converted,
                           NestedNameSpecifierLoc &QualifierLoc) {
Sema::InstantiatingTemplate Inst(
    SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
    SourceRange(TemplateLoc, RAngleLoc));
if (Inst.isInvalid())
  return TemplateName();

TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);

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

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

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

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

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

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

  return TemplateArgumentLoc();
}

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

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

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

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

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

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

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

  QualLoc = ETLoc.getQualifierLoc();
  TLoc = ETLoc.getNamedTypeLoc();
}

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

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

return TemplateArgumentLoc();
4876}

4878/// Check that the given template argument corresponds to the given
4879/// template parameter.
4880///
4881/// \param Param The template parameter against which the argument will be
4882/// checked.
4883///
4884/// \param Arg The template argument, which may be updated due to conversions.
4885///
4886/// \param Template The template in which the template argument resides.
4887///
4888/// \param TemplateLoc The location of the template name for the template
4889/// whose argument list we're matching.
4890///
4891/// \param RAngleLoc The location of the right angle bracket ('>') that closes
4892/// the template argument list.
4893///
4894/// \param ArgumentPackIndex The index into the argument pack where this
4895/// argument will be placed. Only valid if the parameter is a parameter pack.
4896///
4897/// \param Converted The checked, converted argument will be added to the
4898/// end of this small vector.
4899///
4900/// \param CTAK Describes how we arrived at this particular template argument:
4901/// explicitly written, deduced, etc.
4902///
4903/// \returns true on error, false otherwise.
4904bool Sema::CheckTemplateArgument(NamedDecl *Param,
                               TemplateArgumentLoc &Arg,
                               NamedDecl *Template,
                               SourceLocation TemplateLoc,
                               SourceLocation RAngleLoc,
                               unsigned ArgumentPackIndex,
                          SmallVectorImpl<TemplateArgument> &Converted,
                               CheckTemplateArgumentKind CTAK) {
// Check template type parameters.
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
  return CheckTemplateTypeArgument(TTP, Arg, Converted);

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

  // FIXME: Do we need to substitute into parameters here if they're
  // instantiation-dependent but not dependent?
  if (NTTPType->isDependentType() &&
      !isa<TemplateTemplateParmDecl>(Template) &&
      !Template->getDeclContext()->isDependentContext()) {
    // Do substitution on the type of the non-type template parameter.
    InstantiatingTemplate Inst(*this, TemplateLoc, Template,
                               NTTP, Converted,
                               SourceRange(TemplateLoc, RAngleLoc));
    if (Inst.isInvalid())
      return true;

    TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
                                      Converted);

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

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

  switch (Arg.getArgument().getKind()) {
  case TemplateArgument::Null:
    llvm_unreachable("Should never see a NULL template argument here")::llvm::llvm_unreachable_internal("Should never see a NULL template argument here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 4966);

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

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

    Converted.push_back(Result);
    break;
  }

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

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

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

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

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

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

      Converted.push_back(Result);
      break;
    }

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

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

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

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

  case TemplateArgument::Pack:
    llvm_unreachable("Caller must expand template argument packs")::llvm::llvm_unreachable_internal("Caller must expand template argument packs"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5072);
  }

  return false;
}


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

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

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

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

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

switch (Arg.getArgument().getKind()) {
case TemplateArgument::Null:
  llvm_unreachable("Should never see a NULL template argument here")::llvm::llvm_unreachable_internal("Should never see a NULL template argument here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5120);

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

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

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

case TemplateArgument::Declaration:
  llvm_unreachable("Declaration argument with template template parameter")::llvm::llvm_unreachable_internal("Declaration argument with template template parameter"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5139);
case TemplateArgument::Integral:
  llvm_unreachable("Integral argument with template template parameter")::llvm::llvm_unreachable_internal("Integral argument with template template parameter"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5141);
case TemplateArgument::NullPtr:
  llvm_unreachable("Null pointer argument with template template parameter")::llvm::llvm_unreachable_internal("Null pointer argument with template template parameter"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5143);

case TemplateArgument::Pack:
  llvm_unreachable("Caller must expand template argument packs")::llvm::llvm_unreachable_internal("Caller must expand template argument packs"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5146);
}

return false;
5150}

5152/// Check whether the template parameter is a pack expansion, and if so,
5153/// determine the number of parameters produced by that expansion. For instance:
5154///
5155/// \code
5156/// template<typename ...Ts> struct A {
5157///   template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
5158/// };
5159/// \endcode
5160///
5161/// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
5162/// is not a pack expansion, so returns an empty Optional.
5163static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) {
if (NonTypeTemplateParmDecl *NTTP
      = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  if (NTTP->isExpandedParameterPack())
    return NTTP->getNumExpansionTypes();
}

if (TemplateTemplateParmDecl *TTP
      = dyn_cast<TemplateTemplateParmDecl>(Param)) {
  if (TTP->isExpandedParameterPack())
    return TTP->getNumExpansionTemplateParameters();
}

return None;
5177}

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

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

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

TemplateParameterList *Params = TD->getTemplateParameters();

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

5216/// Check that the given template argument list is well-formed
5217/// for specializing the given template.
5218bool Sema::CheckTemplateArgumentList(
  TemplateDecl *Template, SourceLocation TemplateLoc,
  TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
  SmallVectorImpl<TemplateArgument> &Converted,
  bool UpdateArgsWithConversions) {
// Make a copy of the template arguments for processing.  Only make the
// changes at the end when successful in matching the arguments to the
// template.
TemplateArgumentListInfo NewArgs = TemplateArgs;

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

SourceLocation RAngleLoc = NewArgs.getRAngleLoc();

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

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

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

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

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

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

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

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

      return false;
    }

    continue;
  }

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

    return false;
  }

  // If we have a template parameter pack with no more corresponding
  // arguments, just break out now and we'll fill in the argument pack below.
  if ((*Param)->isTemplateParameterPack()) {
    assert(!getExpandedPackSize(*Param) &&((!getExpandedPackSize(*Param) && "Should have dealt with this already"
) ? static_cast<void> (0) : __assert_fail ("!getExpandedPackSize(*Param) && \"Should have dealt with this already\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5345, __PRETTY_FUNCTION__))
           "Should have dealt with this already")((!getExpandedPackSize(*Param) && "Should have dealt with this already"
) ? static_cast<void> (0) : __assert_fail ("!getExpandedPackSize(*Param) && \"Should have dealt with this already\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5345, __PRETTY_FUNCTION__));

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

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

    ++Param;
    continue;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return false;
5477}

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

  typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited;

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

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

5495#define TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *);
5497#define ABSTRACT_TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *) { return false; }
5499#define NON_CANONICAL_TYPE(Class, Parent) \
  bool Visit##Class##Type(const Class##Type *) { return false; }
5501#include "clang/AST/TypeNodes.inc"

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

5508bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
return false;
5510}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5598bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
                                                const UnresolvedUsingType*) {
return false;
5601}

5603bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
return false;
5605}

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

5611bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
return false;
5613}

5615bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
                                                  const UnaryTransformType*) {
return false;
5618}

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

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

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

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

5637bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
                                               const TemplateTypeParmType*) {
return false;
5640}

5642bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
                                      const SubstTemplateTypeParmPackType *) {
return false;
5645}

5647bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
                                          const TemplateSpecializationType*) {
return false;
5650}

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

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

5662bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
                               const DependentTemplateSpecializationType* T) {
return VisitNestedNameSpecifier(T->getQualifier());
5665}

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

5672bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
return false;
5674}

5676bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
                                                 const ObjCInterfaceType *) {
return false;
5679}

5681bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
                                              const ObjCObjectPointerType *) {
return false;
5684}

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

5690bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
return false;
5692}

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

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

return false;
5714}

5716bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
                                                  NestedNameSpecifier *NNS) {
if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
  return true;

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

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
  return Visit(QualType(NNS->getAsType(), 0));
}
llvm_unreachable("Invalid NestedNameSpecifier::Kind!")::llvm::llvm_unreachable_internal("Invalid NestedNameSpecifier::Kind!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5733);
5734}

5736/// Check a template argument against its corresponding
5737/// template type parameter.
5738///
5739/// This routine implements the semantics of C++ [temp.arg.type]. It
5740/// returns true if an error occurred, and false otherwise.
5741bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
                               TypeSourceInfo *ArgInfo) {
assert(ArgInfo && "invalid TypeSourceInfo")((ArgInfo && "invalid TypeSourceInfo") ? static_cast<
void> (0) : __assert_fail ("ArgInfo && \"invalid TypeSourceInfo\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5743, __PRETTY_FUNCTION__));
QualType Arg = ArgInfo->getType();
SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();

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

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

return false;
5766}

5768enum NullPointerValueKind {
NPV_NotNullPointer,
NPV_NullPointer,
NPV_Error
5772};

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

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

if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
  llvm_unreachable(::llvm::llvm_unreachable_internal("Incomplete parameter type in isNullPointerValueTemplateArgument!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5790)
      "Incomplete parameter type in isNullPointerValueTemplateArgument!")::llvm::llvm_unreachable_internal("Incomplete parameter type in isNullPointerValueTemplateArgument!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5790);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return false;
5925}

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

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

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

    if (FirstOpKind == UO_AddrOf)
      AddressTaken = true;
    else if (Arg->getType()->isPointerType()) {
      // We cannot let pointers get dereferenced here, that is obviously not a
      // constant expression.
      assert(FirstOpKind == UO_Deref)((FirstOpKind == UO_Deref) ? static_cast<void> (0) : __assert_fail
 ("FirstOpKind == UO_Deref", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 5972, __PRETTY_FUNCTION__));
      S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
          << Arg->getSourceRange();
    }
  }
} else {
  // See through any implicit casts we added to fix the type.
  Arg = Arg->IgnoreImpCasts();

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

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

    Arg = Parens->getSubExpr();
  }

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

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

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

DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;

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

  case NPV_Error:
    return true;

  case NPV_NotNullPointer:
    break;
  }
}

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

if (isa<CXXUuidofExpr>(Arg)) {
  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
                                                     ArgIn, Arg, ArgType))
    return true;

  Converted = TemplateArgument(ArgIn);
  return false;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Expr *Arg = ResultArg;
bool ObjCLifetimeConversion;

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

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

  Arg = Parens->getSubExpr();
}

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

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

  DRE = nullptr;
}

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

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

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

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

if (isa<FieldDecl>(DRE->getDecl()) ||
    isa<IndirectFieldDecl>(DRE->getDecl()) ||
    isa<CXXMethodDecl>(DRE->getDecl())) {
  assert((isa<FieldDecl>(DRE->getDecl()) ||(((isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl
>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->
getDecl())->isStatic()) && "Only non-static member pointers can make it here"
) ? static_cast<void> (0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6322, __PRETTY_FUNCTION__))
          isa<IndirectFieldDecl>(DRE->getDecl()) ||(((isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl
>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->
getDecl())->isStatic()) && "Only non-static member pointers can make it here"
) ? static_cast<void> (0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6322, __PRETTY_FUNCTION__))
          !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&(((isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl
>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->
getDecl())->isStatic()) && "Only non-static member pointers can make it here"
) ? static_cast<void> (0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6322, __PRETTY_FUNCTION__))
         "Only non-static member pointers can make it here")(((isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl
>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->
getDecl())->isStatic()) && "Only non-static member pointers can make it here"
) ? static_cast<void> (0) : __assert_fail ("(isa<FieldDecl>(DRE->getDecl()) || isa<IndirectFieldDecl>(DRE->getDecl()) || !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && \"Only non-static member pointers can make it here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6322, __PRETTY_FUNCTION__));

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

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

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

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

  // When checking a deduced template argument, deduce from its type even if
  // the type is dependent, in order to check the types of non-type template
  // arguments line up properly in partial ordering.
  Optional<unsigned> Depth = Param->getDepth() + 1;
  Expr *DeductionArg = Arg;
  if (auto *PE = dyn_cast<PackExpansionExpr>(DeductionArg))
    DeductionArg = PE->getPattern();
  if (DeduceAutoType(
          Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
          DeductionArg, ParamType, Depth) == DAR_Failed) {
    Diag(Arg->getExprLoc(),
         diag::err_non_type_template_parm_type_deduction_failure)
      << Param->getDeclName() << Param->getType() << Arg->getType()
      << Arg->getSourceRange();
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }
  // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
  // an error. The error message normally references the parameter
  // declaration, but here we'll pass the argument location because that's
  // where the parameter type is deduced.
  ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
  if (ParamType.isNull()) {
    Diag(Param->getLocation(), diag::note_template_param_here);
    return ExprError();
  }
}

// We should have already dropped all cv-qualifiers by now.
assert(!ParamType.hasQualifiers() &&((!ParamType.hasQualifiers() && "non-type template parameter type cannot be qualified"
) ? static_cast<void> (0) : __assert_fail ("!ParamType.hasQualifiers() && \"non-type template parameter type cannot be qualified\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6400, __PRETTY_FUNCTION__))
       "non-type template parameter type cannot be qualified")((!ParamType.hasQualifiers() && "non-type template parameter type cannot be qualified"
) ? static_cast<void> (0) : __assert_fail ("!ParamType.hasQualifiers() && \"non-type template parameter type cannot be qualified\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6400, __PRETTY_FUNCTION__));

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

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

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

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

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

  QualType CanonParamType = Context.getCanonicalType(ParamType);

  // Convert the APValue to a TemplateArgument.
  switch (Value.getKind()) {
  case APValue::None:
    assert(ParamType->isNullPtrType())((ParamType->isNullPtrType()) ? static_cast<void> (0
) : __assert_fail ("ParamType->isNullPtrType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6481, __PRETTY_FUNCTION__));
    Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  case APValue::Indeterminate:
    llvm_unreachable("result of constant evaluation should be initialized")::llvm::llvm_unreachable_internal("result of constant evaluation should be initialized"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6485);
    break;
  case APValue::Int:
    assert(ParamType->isIntegralOrEnumerationType())((ParamType->isIntegralOrEnumerationType()) ? static_cast<
void> (0) : __assert_fail ("ParamType->isIntegralOrEnumerationType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6488, __PRETTY_FUNCTION__));
    Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
    break;
  case APValue::MemberPointer: {
    assert(ParamType->isMemberPointerType())((ParamType->isMemberPointerType()) ? static_cast<void>
 (0) : __assert_fail ("ParamType->isMemberPointerType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6492, __PRETTY_FUNCTION__));

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

    auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
    Converted = VD ? TemplateArgument(VD, CanonParamType)
                   : TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  }
  case APValue::LValue: {
    //   For a non-type template-parameter of pointer or reference type,
    //   the value of the constant expression shall not refer to
    assert(ParamType->isPointerType() || ParamType->isReferenceType() ||((ParamType->isPointerType() || ParamType->isReferenceType
() || ParamType->isNullPtrType()) ? static_cast<void>
 (0) : __assert_fail ("ParamType->isPointerType() || ParamType->isReferenceType() || ParamType->isNullPtrType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6512, __PRETTY_FUNCTION__))
           ParamType->isNullPtrType())((ParamType->isPointerType() || ParamType->isReferenceType
() || ParamType->isNullPtrType()) ? static_cast<void>
 (0) : __assert_fail ("ParamType->isPointerType() || ParamType->isReferenceType() || ParamType->isNullPtrType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6512, __PRETTY_FUNCTION__));
    // -- a temporary object
    // -- a string literal
    // -- the result of a typeid expression, or
    // -- a predefined __func__ variable
    APValue::LValueBase Base = Value.getLValueBase();
    auto *VD = const_cast<ValueDecl *>(Base.dyn_cast<const ValueDecl *>());
    if (Base && !VD) {
      auto *E = Base.dyn_cast<const Expr *>();
      if (E && isa<CXXUuidofExpr>(E)) {
        Converted = TemplateArgument(ArgResult.get()->IgnoreImpCasts());
        break;
      }
      Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
          << Arg->getSourceRange();
      return ExprError();
    }
    // -- a subobject
    if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
        VD && VD->getType()->isArrayType() &&
        Value.getLValuePath()[0].getAsArrayIndex() == 0 &&
        !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
      // Per defect report (no number yet):
      //   ... other than a pointer to the first element of a complete array
      //       object.
    } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
               Value.isLValueOnePastTheEnd()) {
      Diag(StartLoc, diag::err_non_type_template_arg_subobject)
        << Value.getAsString(Context, ParamType);
      return ExprError();
    }
    assert((VD || !ParamType->isReferenceType()) &&(((VD || !ParamType->isReferenceType()) && "null reference should not be a constant expression"
) ? static_cast<void> (0) : __assert_fail ("(VD || !ParamType->isReferenceType()) && \"null reference should not be a constant expression\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6544, __PRETTY_FUNCTION__))
           "null reference should not be a constant expression")(((VD || !ParamType->isReferenceType()) && "null reference should not be a constant expression"
) ? static_cast<void> (0) : __assert_fail ("(VD || !ParamType->isReferenceType()) && \"null reference should not be a constant expression\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6544, __PRETTY_FUNCTION__));
    assert((!VD || !ParamType->isNullPtrType()) &&(((!VD || !ParamType->isNullPtrType()) && "non-null value of type nullptr_t?"
) ? static_cast<void> (0) : __assert_fail ("(!VD || !ParamType->isNullPtrType()) && \"non-null value of type nullptr_t?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6546, __PRETTY_FUNCTION__))
           "non-null value of type nullptr_t?")(((!VD || !ParamType->isNullPtrType()) && "non-null value of type nullptr_t?"
) ? static_cast<void> (0) : __assert_fail ("(!VD || !ParamType->isNullPtrType()) && \"non-null value of type nullptr_t?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6546, __PRETTY_FUNCTION__));
    Converted = VD ? TemplateArgument(VD, CanonParamType)
                   : TemplateArgument(CanonParamType, /*isNullPtr*/true);
    break;
  }
  case APValue::AddrLabelDiff:
    return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
  case APValue::FixedPoint:
  case APValue::Float:
  case APValue::ComplexInt:
  case APValue::ComplexFloat:
  case APValue::Vector:
  case APValue::Array:
  case APValue::Struct:
  case APValue::Union:
    llvm_unreachable("invalid kind for template argument")::llvm::llvm_unreachable_internal("invalid kind for template argument"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6561);
  }

  return ArgResult.get();
}

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

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

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

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

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

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

  QualType ArgType = Arg->getType();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if (ParamType->isPointerType()) {
  //   -- for a non-type template-parameter of type pointer to
  //      object, qualification conversions (4.4) and the
  //      array-to-pointer conversion (4.2) are applied.
  // C++0x also allows a value of std::nullptr_t.
  assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&((ParamType->getPointeeType()->isIncompleteOrObjectType
() && "Only object pointers allowed here") ? static_cast
<void> (0) : __assert_fail ("ParamType->getPointeeType()->isIncompleteOrObjectType() && \"Only object pointers allowed here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6802, __PRETTY_FUNCTION__))
         "Only object pointers allowed here")((ParamType->getPointeeType()->isIncompleteOrObjectType
() && "Only object pointers allowed here") ? static_cast
<void> (0) : __assert_fail ("ParamType->getPointeeType()->isIncompleteOrObjectType() && \"Only object pointers allowed here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6802, __PRETTY_FUNCTION__));

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

if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
  //   -- For a non-type template-parameter of type reference to
  //      object, no conversions apply. The type referred to by the
  //      reference may be more cv-qualified than the (otherwise
  //      identical) type of the template-argument. The
  //      template-parameter is bound directly to the
  //      template-argument, which must be an lvalue.
  assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&((ParamRefType->getPointeeType()->isIncompleteOrObjectType
() && "Only object references allowed here") ? static_cast
<void> (0) : __assert_fail ("ParamRefType->getPointeeType()->isIncompleteOrObjectType() && \"Only object references allowed here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6819, __PRETTY_FUNCTION__))
         "Only object references allowed here")((ParamRefType->getPointeeType()->isIncompleteOrObjectType
() && "Only object references allowed here") ? static_cast
<void> (0) : __assert_fail ("ParamRefType->getPointeeType()->isIncompleteOrObjectType() && \"Only object references allowed here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6819, __PRETTY_FUNCTION__));

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

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

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

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

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

  case NPV_Error:
    return ExprError();

  case NPV_NullPointer:
    Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
    Converted = TemplateArgument(Context.getCanonicalType(ParamType),
                                 /*isNullPtr*/true);
    return Arg;
  }
}

//     -- For a non-type template-parameter of type pointer to data
//        member, qualification conversions (4.4) are applied.
assert(ParamType->isMemberPointerType() && "Only pointers to members remain")((ParamType->isMemberPointerType() && "Only pointers to members remain"
) ? static_cast<void> (0) : __assert_fail ("ParamType->isMemberPointerType() && \"Only pointers to members remain\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6869, __PRETTY_FUNCTION__));

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

6877static void DiagnoseTemplateParameterListArityMismatch(
  Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
  Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);

6881/// Check a template argument against its corresponding
6882/// template template parameter.
6883///
6884/// This routine implements the semantics of C++ [temp.arg.template].
6885/// It returns true if an error occurred, and false otherwise.
6886bool Sema::CheckTemplateTemplateArgument(TemplateParameterList *Params,
                                       TemplateArgumentLoc &Arg) {
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
TemplateDecl *Template = Name.getAsTemplateDecl();
if (!Template) {
  // Any dependent template name is fine.
  assert(Name.isDependent() && "Non-dependent template isn't a declaration?")((Name.isDependent() && "Non-dependent template isn't a declaration?"
) ? static_cast<void> (0) : __assert_fail ("Name.isDependent() && \"Non-dependent template isn't a declaration?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6892, __PRETTY_FUNCTION__));
  return false;
}

if (Template->isInvalidDecl())
  return true;

// C++0x [temp.arg.template]p1:
//   A template-argument for a template template-parameter shall be
//   the name of a class template or an alias template, expressed as an
//   id-expression. When the template-argument names a class template, only
//   primary class templates are considered when matching the
//   template template argument with the corresponding parameter;
//   partial specializations are not considered even if their
//   parameter lists match that of the template template parameter.
//
// Note that we also allow template template parameters here, which
// will happen when we are dealing with, e.g., class template
// partial specializations.
if (!isa<ClassTemplateDecl>(Template) &&
    !isa<TemplateTemplateParmDecl>(Template) &&
    !isa<TypeAliasTemplateDecl>(Template) &&
    !isa<BuiltinTemplateDecl>(Template)) {
  assert(isa<FunctionTemplateDecl>(Template) &&((isa<FunctionTemplateDecl>(Template) && "Only function templates are possible here"
) ? static_cast<void> (0) : __assert_fail ("isa<FunctionTemplateDecl>(Template) && \"Only function templates are possible here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6916, __PRETTY_FUNCTION__))
         "Only function templates are possible here")((isa<FunctionTemplateDecl>(Template) && "Only function templates are possible here"
) ? static_cast<void> (0) : __assert_fail ("isa<FunctionTemplateDecl>(Template) && \"Only function templates are possible here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6916, __PRETTY_FUNCTION__));
  Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
  Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
    << Template;
}

// C++1z [temp.arg.template]p3: (DR 150)
//   A template-argument matches a template template-parameter P when P
//   is at least as specialized as the template-argument A.
if (getLangOpts().RelaxedTemplateTemplateArgs) {
  // Quick check for the common case:
  //   If P contains a parameter pack, then A [...] matches P if each of A's
  //   template parameters matches the corresponding template parameter in
  //   the template-parameter-list of P.
  if (TemplateParameterListsAreEqual(
          Template->getTemplateParameters(), Params, false,
          TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
    return false;

  if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
                                                        Arg.getLocation()))
    return false;
  // FIXME: Produce better diagnostics for deduction failures.
}

return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
                                       Params,
                                       true,
                                       TPL_TemplateTemplateArgumentMatch,
                                       Arg.getLocation());
6946}

6948/// Given a non-type template argument that refers to a
6949/// declaration and the type of its corresponding non-type template
6950/// parameter, produce an expression that properly refers to that
6951/// declaration.
6952ExprResult
6953Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
                                            QualType ParamType,
                                            SourceLocation Loc) {
// C++ [temp.param]p8:
//
//   A non-type template-parameter of type "array of T" or
//   "function returning T" is adjusted to be of type "pointer to
//   T" or "pointer to function returning T", respectively.
if (ParamType->isArrayType())
  ParamType = Context.getArrayDecayedType(ParamType);
else if (ParamType->isFunctionType())
  ParamType = Context.getPointerType(ParamType);

// For a NULL non-type template argument, return nullptr casted to the
// parameter's type.
if (Arg.getKind() == TemplateArgument::NullPtr) {
  return ImpCastExprToType(
           new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
                           ParamType,
                           ParamType->getAs<MemberPointerType>()
                             ? CK_NullToMemberPointer
                             : CK_NullToPointer);
}
assert(Arg.getKind() == TemplateArgument::Declaration &&((Arg.getKind() == TemplateArgument::Declaration && "Only declaration template arguments permitted here"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Declaration && \"Only declaration template arguments permitted here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6977, __PRETTY_FUNCTION__))
       "Only declaration template arguments permitted here")((Arg.getKind() == TemplateArgument::Declaration && "Only declaration template arguments permitted here"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Declaration && \"Only declaration template arguments permitted here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 6977, __PRETTY_FUNCTION__));

ValueDecl *VD = Arg.getAsDecl();

if (VD->getDeclContext()->isRecord() &&
    (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
     isa<IndirectFieldDecl>(VD))) {
  // If the value is a class member, we might have a pointer-to-member.
  // Determine whether the non-type template template parameter is of
  // pointer-to-member type. If so, we need to build an appropriate
  // expression for a pointer-to-member, since a "normal" DeclRefExpr
  // would refer to the member itself.
  if (ParamType->isMemberPointerType()) {
    QualType ClassType
      = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
    NestedNameSpecifier *Qualifier
      = NestedNameSpecifier::Create(Context, nullptr, false,
                                    ClassType.getTypePtr());
    CXXScopeSpec SS;
    SS.MakeTrivial(Context, Qualifier, Loc);

    // The actual value-ness of this is unimportant, but for
    // internal consistency's sake, references to instance methods
    // are r-values.
    ExprValueKind VK = VK_LValue;
    if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
      VK = VK_RValue;

    ExprResult RefExpr = BuildDeclRefExpr(VD,
                                          VD->getType().getNonReferenceType(),
                                          VK,
                                          Loc,
                                          &SS);
    if (RefExpr.isInvalid())
      return ExprError();

    RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());

    // We might need to perform a trailing qualification conversion, since
    // the element type on the parameter could be more qualified than the
    // element type in the expression we constructed.
    bool ObjCLifetimeConversion;
    if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
                                  ParamType.getUnqualifiedType(), false,
                                  ObjCLifetimeConversion))
      RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);

    assert(!RefExpr.isInvalid() &&((!RefExpr.isInvalid() && Context.hasSameType(((Expr*
) RefExpr.get())->getType(), ParamType.getUnqualifiedType(
))) ? static_cast<void> (0) : __assert_fail ("!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType())"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7026, __PRETTY_FUNCTION__))
           Context.hasSameType(((Expr*) RefExpr.get())->getType(),((!RefExpr.isInvalid() && Context.hasSameType(((Expr*
) RefExpr.get())->getType(), ParamType.getUnqualifiedType(
))) ? static_cast<void> (0) : __assert_fail ("!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType())"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7026, __PRETTY_FUNCTION__))
                               ParamType.getUnqualifiedType()))((!RefExpr.isInvalid() && Context.hasSameType(((Expr*
) RefExpr.get())->getType(), ParamType.getUnqualifiedType(
))) ? static_cast<void> (0) : __assert_fail ("!RefExpr.isInvalid() && Context.hasSameType(((Expr*) RefExpr.get())->getType(), ParamType.getUnqualifiedType())"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7026, __PRETTY_FUNCTION__));
    return RefExpr;
  }
}

QualType T = VD->getType().getNonReferenceType();

if (ParamType->isPointerType()) {
  // When the non-type template parameter is a pointer, take the
  // address of the declaration.
  ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
  if (RefExpr.isInvalid())
    return ExprError();

  if (!Context.hasSameUnqualifiedType(ParamType->getPointeeType(), T) &&
      (T->isFunctionType() || T->isArrayType())) {
    // Decay functions and arrays unless we're forming a pointer to array.
    RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
    if (RefExpr.isInvalid())
      return ExprError();

    return RefExpr;
  }

  // Take the address of everything else
  return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
}

ExprValueKind VK = VK_RValue;

// If the non-type template parameter has reference type, qualify the
// resulting declaration reference with the extra qualifiers on the
// type that the reference refers to.
if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
  VK = VK_LValue;
  T = Context.getQualifiedType(T,
                            TargetRef->getPointeeType().getQualifiers());
} else if (isa<FunctionDecl>(VD)) {
  // References to functions are always lvalues.
  VK = VK_LValue;
}

return BuildDeclRefExpr(VD, T, VK, Loc);
7069}

7071/// Construct a new expression that refers to the given
7072/// integral template argument with the given source-location
7073/// information.
7074///
7075/// This routine takes care of the mapping from an integral template
7076/// argument (which may have any integral type) to the appropriate
7077/// literal value.
7078ExprResult
7079Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
                                                SourceLocation Loc) {
assert(Arg.getKind() == TemplateArgument::Integral &&((Arg.getKind() == TemplateArgument::Integral && "Operation is only valid for integral template arguments"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Integral && \"Operation is only valid for integral template arguments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7082, __PRETTY_FUNCTION__))
       "Operation is only valid for integral template arguments")((Arg.getKind() == TemplateArgument::Integral && "Operation is only valid for integral template arguments"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Integral && \"Operation is only valid for integral template arguments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7082, __PRETTY_FUNCTION__));
QualType OrigT = Arg.getIntegralType();

// If this is an enum type that we're instantiating, we need to use an integer
// type the same size as the enumerator.  We don't want to build an
// IntegerLiteral with enum type.  The integer type of an enum type can be of
// any integral type with C++11 enum classes, make sure we create the right
// type of literal for it.
QualType T = OrigT;
if (const EnumType *ET = OrigT->getAs<EnumType>())
  T = ET->getDecl()->getIntegerType();

Expr *E;
if (T->isAnyCharacterType()) {
  CharacterLiteral::CharacterKind Kind;
  if (T->isWideCharType())
    Kind = CharacterLiteral::Wide;
  else if (T->isChar8Type() && getLangOpts().Char8)
    Kind = CharacterLiteral::UTF8;
  else if (T->isChar16Type())
    Kind = CharacterLiteral::UTF16;
  else if (T->isChar32Type())
    Kind = CharacterLiteral::UTF32;
  else
    Kind = CharacterLiteral::Ascii;

  E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
                                     Kind, T, Loc);
} else if (T->isBooleanType()) {
  E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
                                       T, Loc);
} else if (T->isNullPtrType()) {
  E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
} else {
  E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
}

if (OrigT->isEnumeralType()) {
  // FIXME: This is a hack. We need a better way to handle substituted
  // non-type template parameters.
  E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
                             nullptr,
                             Context.getTrivialTypeSourceInfo(OrigT, Loc),
                             Loc, Loc);
}

return E;
7129}

7131/// Match two template parameters within template parameter lists.
7132static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
                                     bool Complain,
                                   Sema::TemplateParameterListEqualKind Kind,
                                     SourceLocation TemplateArgLoc) {
// Check the actual kind (type, non-type, template).
if (Old->getKind() != New->getKind()) {
  if (Complain) {
    unsigned NextDiag = diag::err_template_param_different_kind;
    if (TemplateArgLoc.isValid()) {
      S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
      NextDiag = diag::note_template_param_different_kind;
    }
    S.Diag(New->getLocation(), NextDiag)
      << (Kind != Sema::TPL_TemplateMatch);
    S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
      << (Kind != Sema::TPL_TemplateMatch);
  }

  return false;
}

// Check that both are parameter packs or neither are parameter packs.
// However, if we are matching a template template argument to a
// template template parameter, the template template parameter can have
// a parameter pack where the template template argument does not.
if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
    !(Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
      Old->isTemplateParameterPack())) {
  if (Complain) {
    unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
    if (TemplateArgLoc.isValid()) {
      S.Diag(TemplateArgLoc,
           diag::err_template_arg_template_params_mismatch);
      NextDiag = diag::note_template_parameter_pack_non_pack;
    }

    unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
                    : isa<NonTypeTemplateParmDecl>(New)? 1
                    : 2;
    S.Diag(New->getLocation(), NextDiag)
      << ParamKind << New->isParameterPack();
    S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
      << ParamKind << Old->isParameterPack();
  }

  return false;
}

// For non-type template parameters, check the type of the parameter.
if (NonTypeTemplateParmDecl *OldNTTP
                                  = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
  NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);

  // If we are matching a template template argument to a template
  // template parameter and one of the non-type template parameter types
  // is dependent, then we must wait until template instantiation time
  // to actually compare the arguments.
  if (Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
      (OldNTTP->getType()->isDependentType() ||
       NewNTTP->getType()->isDependentType()))
    return true;

  if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
    if (Complain) {
      unsigned NextDiag = diag::err_template_nontype_parm_different_type;
      if (TemplateArgLoc.isValid()) {
        S.Diag(TemplateArgLoc,
               diag::err_template_arg_template_params_mismatch);
        NextDiag = diag::note_template_nontype_parm_different_type;
      }
      S.Diag(NewNTTP->getLocation(), NextDiag)
        << NewNTTP->getType()
        << (Kind != Sema::TPL_TemplateMatch);
      S.Diag(OldNTTP->getLocation(),
             diag::note_template_nontype_parm_prev_declaration)
        << OldNTTP->getType();
    }

    return false;
  }

  return true;
}

// For template template parameters, check the template parameter types.
// The template parameter lists of template template
// parameters must agree.
if (TemplateTemplateParmDecl *OldTTP
                                  = dyn_cast<TemplateTemplateParmDecl>(Old)) {
  TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
  return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
                                          OldTTP->getTemplateParameters(),
                                          Complain,
                                      (Kind == Sema::TPL_TemplateMatch
                                         ? Sema::TPL_TemplateTemplateParmMatch
                                         : Kind),
                                          TemplateArgLoc);
}

return true;
7232}

7234/// Diagnose a known arity mismatch when comparing template argument
7235/// lists.
7236static
7237void DiagnoseTemplateParameterListArityMismatch(Sema &S,
                                              TemplateParameterList *New,
                                              TemplateParameterList *Old,
                                    Sema::TemplateParameterListEqualKind Kind,
                                              SourceLocation TemplateArgLoc) {
unsigned NextDiag = diag::err_template_param_list_different_arity;
if (TemplateArgLoc.isValid()) {
  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
  NextDiag = diag::note_template_param_list_different_arity;
}
S.Diag(New->getTemplateLoc(), NextDiag)
  << (New->size() > Old->size())
  << (Kind != Sema::TPL_TemplateMatch)
  << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
  << (Kind != Sema::TPL_TemplateMatch)
  << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
7254}

7256/// Determine whether the given template parameter lists are
7257/// equivalent.
7258///
7259/// \param New  The new template parameter list, typically written in the
7260/// source code as part of a new template declaration.
7261///
7262/// \param Old  The old template parameter list, typically found via
7263/// name lookup of the template declared with this template parameter
7264/// list.
7265///
7266/// \param Complain  If true, this routine will produce a diagnostic if
7267/// the template parameter lists are not equivalent.
7268///
7269/// \param Kind describes how we are to match the template parameter lists.
7270///
7271/// \param TemplateArgLoc If this source location is valid, then we
7272/// are actually checking the template parameter list of a template
7273/// argument (New) against the template parameter list of its
7274/// corresponding template template parameter (Old). We produce
7275/// slightly different diagnostics in this scenario.
7276///
7277/// \returns True if the template parameter lists are equal, false
7278/// otherwise.
7279bool
7280Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
                                   TemplateParameterList *Old,
                                   bool Complain,
                                   TemplateParameterListEqualKind Kind,
                                   SourceLocation TemplateArgLoc) {
if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
  if (Complain)
    DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                               TemplateArgLoc);

  return false;
}

// C++0x [temp.arg.template]p3:
//   A template-argument matches a template template-parameter (call it P)
//   when each of the template parameters in the template-parameter-list of
//   the template-argument's corresponding class template or alias template
//   (call it A) matches the corresponding template parameter in the
//   template-parameter-list of P. [...]
TemplateParameterList::iterator NewParm = New->begin();
TemplateParameterList::iterator NewParmEnd = New->end();
for (TemplateParameterList::iterator OldParm = Old->begin(),
                                  OldParmEnd = Old->end();
     OldParm != OldParmEnd; ++OldParm) {
  if (Kind != TPL_TemplateTemplateArgumentMatch ||
      !(*OldParm)->isTemplateParameterPack()) {
    if (NewParm == NewParmEnd) {
      if (Complain)
        DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                                   TemplateArgLoc);

      return false;
    }

    if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
                                    Kind, TemplateArgLoc))
      return false;

    ++NewParm;
    continue;
  }

  // C++0x [temp.arg.template]p3:
  //   [...] When P's template- parameter-list contains a template parameter
  //   pack (14.5.3), the template parameter pack will match zero or more
  //   template parameters or template parameter packs in the
  //   template-parameter-list of A with the same type and form as the
  //   template parameter pack in P (ignoring whether those template
  //   parameters are template parameter packs).
  for (; NewParm != NewParmEnd; ++NewParm) {
    if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
                                    Kind, TemplateArgLoc))
      return false;
  }
}

// Make sure we exhausted all of the arguments.
if (NewParm != NewParmEnd) {
  if (Complain)
    DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                               TemplateArgLoc);

  return false;
}

return true;
7346}

7348/// Check whether a template can be declared within this scope.
7349///
7350/// If the template declaration is valid in this scope, returns
7351/// false. Otherwise, issues a diagnostic and returns true.
7352bool
7353Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
if (!S)
  return false;

// Find the nearest enclosing declaration scope.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
       (S->getFlags() & Scope::TemplateParamScope) != 0)
  S = S->getParent();

// C++ [temp]p4:
//   A template [...] shall not have C linkage.
DeclContext *Ctx = S->getEntity();
if (Ctx && Ctx->isExternCContext()) {
  Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
      << TemplateParams->getSourceRange();
  if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
    Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
  return true;
}
Ctx = Ctx->getRedeclContext();

// C++ [temp]p2:
//   A template-declaration can appear only as a namespace scope or
//   class scope declaration.
if (Ctx) {
  if (Ctx->isFileContext())
    return false;
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
    // C++ [temp.mem]p2:
    //   A local class shall not have member templates.
    if (RD->isLocalClass())
      return Diag(TemplateParams->getTemplateLoc(),
                  diag::err_template_inside_local_class)
        << TemplateParams->getSourceRange();
    else
      return false;
  }
}

return Diag(TemplateParams->getTemplateLoc(),
            diag::err_template_outside_namespace_or_class_scope)
  << TemplateParams->getSourceRange();
7395}

7397/// Determine what kind of template specialization the given declaration
7398/// is.
7399static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) {
if (!D)
  return TSK_Undeclared;

if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
  return Record->getTemplateSpecializationKind();
if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
  return Function->getTemplateSpecializationKind();
if (VarDecl *Var = dyn_cast<VarDecl>(D))
  return Var->getTemplateSpecializationKind();

return TSK_Undeclared;
7411}

7413/// Check whether a specialization is well-formed in the current
7414/// context.
7415///
7416/// This routine determines whether a template specialization can be declared
7417/// in the current context (C++ [temp.expl.spec]p2).
7418///
7419/// \param S the semantic analysis object for which this check is being
7420/// performed.
7421///
7422/// \param Specialized the entity being specialized or instantiated, which
7423/// may be a kind of template (class template, function template, etc.) or
7424/// a member of a class template (member function, static data member,
7425/// member class).
7426///
7427/// \param PrevDecl the previous declaration of this entity, if any.
7428///
7429/// \param Loc the location of the explicit specialization or instantiation of
7430/// this entity.
7431///
7432/// \param IsPartialSpecialization whether this is a partial specialization of
7433/// a class template.
7434///
7435/// \returns true if there was an error that we cannot recover from, false
7436/// otherwise.
7437static bool CheckTemplateSpecializationScope(Sema &S,
                                           NamedDecl *Specialized,
                                           NamedDecl *PrevDecl,
                                           SourceLocation Loc,
                                           bool IsPartialSpecialization) {
// Keep these "kind" numbers in sync with the %select statements in the
// various diagnostics emitted by this routine.
int EntityKind = 0;
if (isa<ClassTemplateDecl>(Specialized))
  EntityKind = IsPartialSpecialization? 1 : 0;
else if (isa<VarTemplateDecl>(Specialized))
  EntityKind = IsPartialSpecialization ? 3 : 2;
else if (isa<FunctionTemplateDecl>(Specialized))
  EntityKind = 4;
else if (isa<CXXMethodDecl>(Specialized))
  EntityKind = 5;
else if (isa<VarDecl>(Specialized))
  EntityKind = 6;
else if (isa<RecordDecl>(Specialized))
  EntityKind = 7;
else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
  EntityKind = 8;
else {
  S.Diag(Loc, diag::err_template_spec_unknown_kind)
    << S.getLangOpts().CPlusPlus11;
  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
  return true;
}

// C++ [temp.expl.spec]p2:
//   An explicit specialization may be declared in any scope in which
//   the corresponding primary template may be defined.
if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) {
  S.Diag(Loc, diag::err_template_spec_decl_function_scope)
    << Specialized;
  return true;
}

// C++ [temp.class.spec]p6:
//   A class template partial specialization may be declared in any
//   scope in which the primary template may be defined.
DeclContext *SpecializedContext =
    Specialized->getDeclContext()->getRedeclContext();
DeclContext *DC = S.CurContext->getRedeclContext();

// Make sure that this redeclaration (or definition) occurs in the same
// scope or an enclosing namespace.
if (!(DC->isFileContext() ? DC->Encloses(SpecializedContext)
                          : DC->Equals(SpecializedContext))) {
  if (isa<TranslationUnitDecl>(SpecializedContext))
    S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
      << EntityKind << Specialized;
  else {
    auto *ND = cast<NamedDecl>(SpecializedContext);
    int Diag = diag::err_template_spec_redecl_out_of_scope;
    if (S.getLangOpts().MicrosoftExt && !DC->isRecord())
      Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
    S.Diag(Loc, Diag) << EntityKind << Specialized
                      << ND << isa<CXXRecordDecl>(ND);
  }

  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);

  // Don't allow specializing in the wrong class during error recovery.
  // Otherwise, things can go horribly wrong.
  if (DC->isRecord())
    return true;
}

return false;
7507}

7509static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E) {
if (!E->isTypeDependent())
  return SourceLocation();
DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Checker.TraverseStmt(E);
if (Checker.MatchLoc.isInvalid())
  return E->getSourceRange();
return Checker.MatchLoc;
7517}

7519static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) {
if (!TL.getType()->isDependentType())
  return SourceLocation();
DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Checker.TraverseTypeLoc(TL);
if (Checker.MatchLoc.isInvalid())
  return TL.getSourceRange();
return Checker.MatchLoc;
7527}

7529/// Subroutine of Sema::CheckTemplatePartialSpecializationArgs
7530/// that checks non-type template partial specialization arguments.
7531static bool CheckNonTypeTemplatePartialSpecializationArgs(
  Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
  const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
for (unsigned I = 0; I != NumArgs; ++I) {
  if (Args[I].getKind() == TemplateArgument::Pack) {
    if (CheckNonTypeTemplatePartialSpecializationArgs(
            S, TemplateNameLoc, Param, Args[I].pack_begin(),
            Args[I].pack_size(), IsDefaultArgument))
      return true;

    continue;
  }

  if (Args[I].getKind() != TemplateArgument::Expression)
    continue;

  Expr *ArgExpr = Args[I].getAsExpr();

  // We can have a pack expansion of any of the bullets below.
  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
    ArgExpr = Expansion->getPattern();

  // Strip off any implicit casts we added as part of type checking.
  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
    ArgExpr = ICE->getSubExpr();

  // C++ [temp.class.spec]p8:
  //   A non-type argument is non-specialized if it is the name of a
  //   non-type parameter. All other non-type arguments are
  //   specialized.
  //
  // Below, we check the two conditions that only apply to
  // specialized non-type arguments, so skip any non-specialized
  // arguments.
  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
    if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
      continue;

  // C++ [temp.class.spec]p9:
  //   Within the argument list of a class template partial
  //   specialization, the following restrictions apply:
  //     -- A partially specialized non-type argument expression
  //        shall not involve a template parameter of the partial
  //        specialization except when the argument expression is a
  //        simple identifier.
  //     -- The type of a template parameter corresponding to a
  //        specialized non-type argument shall not be dependent on a
  //        parameter of the specialization.
  // DR1315 removes the first bullet, leaving an incoherent set of rules.
  // We implement a compromise between the original rules and DR1315:
  //     --  A specialized non-type template argument shall not be
  //         type-dependent and the corresponding template parameter
  //         shall have a non-dependent type.
  SourceRange ParamUseRange =
      findTemplateParameterInType(Param->getDepth(), ArgExpr);
  if (ParamUseRange.isValid()) {
    if (IsDefaultArgument) {
      S.Diag(TemplateNameLoc,
             diag::err_dependent_non_type_arg_in_partial_spec);
      S.Diag(ParamUseRange.getBegin(),
             diag::note_dependent_non_type_default_arg_in_partial_spec)
        << ParamUseRange;
    } else {
      S.Diag(ParamUseRange.getBegin(),
             diag::err_dependent_non_type_arg_in_partial_spec)
        << ParamUseRange;
    }
    return true;
  }

  ParamUseRange = findTemplateParameter(
      Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
  if (ParamUseRange.isValid()) {
    S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getBeginLoc(),
           diag::err_dependent_typed_non_type_arg_in_partial_spec)
        << Param->getType();
    S.Diag(Param->getLocation(), diag::note_template_param_here)
      << (IsDefaultArgument ? ParamUseRange : SourceRange())
      << ParamUseRange;
    return true;
  }
}

return false;
7615}

7617/// Check the non-type template arguments of a class template
7618/// partial specialization according to C++ [temp.class.spec]p9.
7619///
7620/// \param TemplateNameLoc the location of the template name.
7621/// \param PrimaryTemplate the template parameters of the primary class
7622///        template.
7623/// \param NumExplicit the number of explicitly-specified template arguments.
7624/// \param TemplateArgs the template arguments of the class template
7625///        partial specialization.
7626///
7627/// \returns \c true if there was an error, \c false otherwise.
7628bool Sema::CheckTemplatePartialSpecializationArgs(
  SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
  unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
// We have to be conservative when checking a template in a dependent
// context.
if (PrimaryTemplate->getDeclContext()->isDependentContext())
  return false;

TemplateParameterList *TemplateParams =
    PrimaryTemplate->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
  NonTypeTemplateParmDecl *Param
    = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
  if (!Param)
    continue;

  if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
                                                    Param, &TemplateArgs[I],
                                                    1, I >= NumExplicit))
    return true;
}

return false;
7651}

7653DeclResult Sema::ActOnClassTemplateSpecialization(
  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
  SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId,
  const ParsedAttributesView &Attr,
  MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {
assert(TUK != TUK_Reference && "References are not specializations")((TUK != TUK_Reference && "References are not specializations"
) ? static_cast<void> (0) : __assert_fail ("TUK != TUK_Reference && \"References are not specializations\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7658, __PRETTY_FUNCTION__));

CXXScopeSpec &SS = TemplateId.SS;

// NOTE: KWLoc is the location of the tag keyword. This will instead
// store the location of the outermost template keyword in the declaration.
SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
  ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
SourceLocation LAngleLoc = TemplateId.LAngleLoc;
SourceLocation RAngleLoc = TemplateId.RAngleLoc;

// Find the class template we're specializing
TemplateName Name = TemplateId.Template.get();
ClassTemplateDecl *ClassTemplate
  = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());

if (!ClassTemplate) {
  Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
    << (Name.getAsTemplateDecl() &&
        isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
  return true;
}

bool isMemberSpecialization = false;
bool isPartialSpecialization = false;

// Check the validity of the template headers that introduce this
// template.
// FIXME: We probably shouldn't complain about these headers for
// friend declarations.
bool Invalid = false;
TemplateParameterList *TemplateParams =
    MatchTemplateParametersToScopeSpecifier(
        KWLoc, TemplateNameLoc, SS, &TemplateId,
        TemplateParameterLists, TUK == TUK_Friend, isMemberSpecialization,
        Invalid);
if (Invalid)
  return true;

if (TemplateParams && TemplateParams->size() > 0) {
  isPartialSpecialization = true;

  if (TUK == TUK_Friend) {
    Diag(KWLoc, diag::err_partial_specialization_friend)
      << SourceRange(LAngleLoc, RAngleLoc);
    return true;
  }

  // C++ [temp.class.spec]p10:
  //   The template parameter list of a specialization shall not
  //   contain default template argument values.
  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
    Decl *Param = TemplateParams->getParam(I);
    if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
      if (TTP->hasDefaultArgument()) {
        Diag(TTP->getDefaultArgumentLoc(),
             diag::err_default_arg_in_partial_spec);
        TTP->removeDefaultArgument();
      }
    } else if (NonTypeTemplateParmDecl *NTTP
                 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
      if (Expr *DefArg = NTTP->getDefaultArgument()) {
        Diag(NTTP->getDefaultArgumentLoc(),
             diag::err_default_arg_in_partial_spec)
          << DefArg->getSourceRange();
        NTTP->removeDefaultArgument();
      }
    } else {
      TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
      if (TTP->hasDefaultArgument()) {
        Diag(TTP->getDefaultArgument().getLocation(),
             diag::err_default_arg_in_partial_spec)
          << TTP->getDefaultArgument().getSourceRange();
        TTP->removeDefaultArgument();
      }
    }
  }
} else if (TemplateParams) {
  if (TUK == TUK_Friend)
    Diag(KWLoc, diag::err_template_spec_friend)
      << FixItHint::CreateRemoval(
                              SourceRange(TemplateParams->getTemplateLoc(),
                                          TemplateParams->getRAngleLoc()))
      << SourceRange(LAngleLoc, RAngleLoc);
} else {
  assert(TUK == TUK_Friend && "should have a 'template<>' for this decl")((TUK == TUK_Friend && "should have a 'template<>' for this decl"
) ? static_cast<void> (0) : __assert_fail ("TUK == TUK_Friend && \"should have a 'template<>' for this decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7744, __PRETTY_FUNCTION__));
}

// Check that the specialization uses the same tag kind as the
// original template.
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!")((Kind != TTK_Enum && "Invalid enum tag in class template spec!"
) ? static_cast<void> (0) : __assert_fail ("Kind != TTK_Enum && \"Invalid enum tag in class template spec!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 7750, __PRETTY_FUNCTION__));
if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
                                  Kind, TUK == TUK_Definition, KWLoc,
                                  ClassTemplate->getIdentifier())) {
  Diag(KWLoc, diag::err_use_with_wrong_tag)
    << ClassTemplate
    << FixItHint::CreateReplacement(KWLoc,
                          ClassTemplate->getTemplatedDecl()->getKindName());
  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
       diag::note_previous_use);
  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
}

// Translate the parser's template argument list in our AST format.
TemplateArgumentListInfo TemplateArgs =
    makeTemplateArgumentListInfo(*this, TemplateId);

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

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

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

  // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
  // also do it during instantiation.
  bool InstantiationDependent;
  if (!Name.isDependent() &&
      !TemplateSpecializationType::anyDependentTemplateArguments(
          TemplateArgs.arguments(), InstantiationDependent)) {
    Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
      << ClassTemplate->getDeclName();
    isPartialSpecialization = false;
  }
}

void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl = nullptr;

if (isPartialSpecialization)
  // FIXME: Template parameter list matters, too
  PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
else
  PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);

ClassTemplateSpecializationDecl *Specialization = nullptr;

// Check whether we can declare a class template specialization in
// the current scope.
if (TUK != TUK_Friend &&
    CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
                                     TemplateNameLoc,
                                     isPartialSpecialization))
  return true;

// The canonical type
QualType CanonType;
if (isPartialSpecialization) {
  // Build the canonical type that describes the converted template
  // arguments of the class template partial specialization.
  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
  CanonType = Context.getTemplateSpecializationType(CanonTemplate,
                                                    Converted);

  if (Context.hasSameType(CanonType,
                      ClassTemplate->getInjectedClassNameSpecialization())) {
    // C++ [temp.class.spec]p9b3:
    //
    //   -- The argument list of the specialization shall not be identical
    //      to the implicit argument list of the primary template.
    //
    // This rule has since been removed, because it's redundant given DR1495,
    // but we keep it because it produces better diagnostics and recovery.
    Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
      << /*class template*/0 << (TUK == TUK_Definition)
      << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
    return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
                              ClassTemplate->getIdentifier(),
                              TemplateNameLoc,
                              Attr,
                              TemplateParams,
                              AS_none, /*ModulePrivateLoc=*/SourceLocation(),
                              /*FriendLoc*/SourceLocation(),
                              TemplateParameterLists.size() - 1,
                              TemplateParameterLists.data());
  }

  // Create a new class template partial specialization declaration node.
  ClassTemplatePartialSpecializationDecl *PrevPartial
    = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
  ClassTemplatePartialSpecializationDecl *Partial
    = ClassTemplatePartialSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                                     KWLoc, TemplateNameLoc,
                                                     TemplateParams,
                                                     ClassTemplate,
                                                     Converted,
                                                     TemplateArgs,
                                                     CanonType,
                                                     PrevPartial);
  SetNestedNameSpecifier(*this, Partial, SS);
  if (TemplateParameterLists.size() > 1 && SS.isSet()) {
    Partial->setTemplateParameterListsInfo(
        Context, TemplateParameterLists.drop_back(1));
  }

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

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

  CheckTemplatePartialSpecialization(Partial);
} else {
  // Create a new class template specialization declaration node for
  // this explicit specialization or friend declaration.
  Specialization
    = ClassTemplateSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                              KWLoc, TemplateNameLoc,
                                              ClassTemplate,
                                              Converted,
                                              PrevDecl);
  SetNestedNameSpecifier(*this, Specialization, SS);
  if (TemplateParameterLists.size() > 0) {
    Specialization->setTemplateParameterListsInfo(Context,
                                                  TemplateParameterLists);
  }

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

  if (CurContext->isDependentContext()) {
    TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
    CanonType = Context.getTemplateSpecializationType(
        CanonTemplate, Converted);
  } else {
    CanonType = Context.getTypeDeclType(Specialization);
  }
}

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

  if (!Okay) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
      << Context.getTypeDeclType(Specialization) << Range;

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

// If this is not a friend, note that this is an explicit specialization.
if (TUK != TUK_Friend)
  Specialization->setSpecializationKind(TSK_ExplicitSpecialization);

// Check that this isn't a redefinition of this specialization.
if (TUK == TUK_Definition) {
  RecordDecl *Def = Specialization->getDefinition();
  NamedDecl *Hidden = nullptr;
  if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
    SkipBody->ShouldSkip = true;
    SkipBody->Previous = Def;
    makeMergedDefinitionVisible(Hidden);
  } else if (Def) {
    SourceRange Range(TemplateNameLoc, RAngleLoc);
    Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
    Diag(Def->getLocation(), diag::note_previous_definition);
    Specialization->setInvalidDecl();
    return true;
  }
}

ProcessDeclAttributeList(S, Specialization, Attr);

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

if (ModulePrivateLoc.isValid())
  Diag(Specialization->getLocation(), diag::err_module_private_specialization)
    << (isPartialSpecialization? 1 : 0)
    << FixItHint::CreateRemoval(ModulePrivateLoc);

// Build the fully-sugared type for this class template
// specialization as the user wrote in the specialization
// itself. This means that we'll pretty-print the type retrieved
// from the specialization's declaration the way that the user
// actually wrote the specialization, rather than formatting the
// name based on the "canonical" representation used to store the
// template arguments in the specialization.
TypeSourceInfo *WrittenTy
  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                              TemplateArgs, CanonType);
if (TUK != TUK_Friend) {
  Specialization->setTypeAsWritten(WrittenTy);
  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
}

// C++ [temp.expl.spec]p9:
//   A template explicit specialization is in the scope of the
//   namespace in which the template was defined.
//
// We actually implement this paragraph where we set the semantic
// context (in the creation of the ClassTemplateSpecializationDecl),
// but we also maintain the lexical context where the actual
// definition occurs.
Specialization->setLexicalDeclContext(CurContext);

// We may be starting the definition of this specialization.
if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip))
  Specialization->startDefinition();

if (TUK == TUK_Friend) {
  FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
                                          TemplateNameLoc,
                                          WrittenTy,
                                          /*FIXME:*/KWLoc);
  Friend->setAccess(AS_public);
  CurContext->addDecl(Friend);
} else {
  // Add the specialization into its lexical context, so that it can
  // be seen when iterating through the list of declarations in that
  // context. However, specializations are not found by name lookup.
  CurContext->addDecl(Specialization);
}

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

return Specialization;
8018}

8020Decl *Sema::ActOnTemplateDeclarator(Scope *S,
                            MultiTemplateParamsArg TemplateParameterLists,
                                  Declarator &D) {
Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
ActOnDocumentableDecl(NewDecl);
return NewDecl;
8026}

8028Decl *Sema::ActOnConceptDefinition(Scope *S,
                            MultiTemplateParamsArg TemplateParameterLists,
                                 IdentifierInfo *Name, SourceLocation NameLoc,
                                 Expr *ConstraintExpr) {
DeclContext *DC = CurContext;

if (!DC->getRedeclContext()->isFileContext()) {
  Diag(NameLoc,
    diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
  return nullptr;
}

if (TemplateParameterLists.size() > 1) {
  Diag(NameLoc, diag::err_concept_extra_headers);
  return nullptr;
}

if (TemplateParameterLists.front()->size() == 0) {
  Diag(NameLoc, diag::err_concept_no_parameters);
  return nullptr;
}

ConceptDecl *NewDecl = ConceptDecl::Create(Context, DC, NameLoc, Name,
                                           TemplateParameterLists.front(),
                                           ConstraintExpr);

if (!ConstraintExpr->isTypeDependent() &&
    ConstraintExpr->getType() != Context.BoolTy) {
  // C++2a [temp.constr.atomic]p3:
  // E shall be a constant expression of type bool.
  // TODO: Do this check for individual atomic constraints
  // and not the constraint expression. Probably should do it in
  // ParseConstraintExpression.
  Diag(ConstraintExpr->getSourceRange().getBegin(),
      diag::err_concept_initialized_with_non_bool_type)
    << ConstraintExpr->getType();
  NewDecl->setInvalidDecl();
}

if (NewDecl->getAssociatedConstraints()) {
  // C++2a [temp.concept]p4:
  // A concept shall not have associated constraints.
  // TODO: Make a test once we have actual associated constraints.
  Diag(NameLoc, diag::err_concept_no_associated_constraints);
  NewDecl->setInvalidDecl();
}

// Check for conflicting previous declaration.
DeclarationNameInfo NameInfo(NewDecl->getDeclName(), NameLoc);
LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                      ForVisibleRedeclaration);
LookupName(Previous, S);

FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage=*/false,
                     /*AllowInlineNamespace*/false);
if (!Previous.empty()) {
  auto *Old = Previous.getRepresentativeDecl();
  Diag(NameLoc, isa<ConceptDecl>(Old) ? diag::err_redefinition :
       diag::err_redefinition_different_kind) << NewDecl->getDeclName();
  Diag(Old->getLocation(), diag::note_previous_definition);
}

ActOnDocumentableDecl(NewDecl);
PushOnScopeChains(NewDecl, S);
return NewDecl;
8093}

8095/// \brief Strips various properties off an implicit instantiation
8096/// that has just been explicitly specialized.
8097static void StripImplicitInstantiation(NamedDecl *D) {
D->dropAttr<DLLImportAttr>();
D->dropAttr<DLLExportAttr>();

if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
  FD->setInlineSpecified(false);
8103}

8105/// Compute the diagnostic location for an explicit instantiation
8106//  declaration or definition.
8107static SourceLocation DiagLocForExplicitInstantiation(
  NamedDecl* D, SourceLocation PointOfInstantiation) {
// Explicit instantiations following a specialization have no effect and
// hence no PointOfInstantiation. In that case, walk decl backwards
// until a valid name loc is found.
SourceLocation PrevDiagLoc = PointOfInstantiation;
for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
     Prev = Prev->getPreviousDecl()) {
  PrevDiagLoc = Prev->getLocation();
}
assert(PrevDiagLoc.isValid() &&((PrevDiagLoc.isValid() && "Explicit instantiation without point of instantiation?"
) ? static_cast<void> (0) : __assert_fail ("PrevDiagLoc.isValid() && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8118, __PRETTY_FUNCTION__))
       "Explicit instantiation without point of instantiation?")((PrevDiagLoc.isValid() && "Explicit instantiation without point of instantiation?"
) ? static_cast<void> (0) : __assert_fail ("PrevDiagLoc.isValid() && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8118, __PRETTY_FUNCTION__));
return PrevDiagLoc;
8120}

8122/// Diagnose cases where we have an explicit template specialization
8123/// before/after an explicit template instantiation, producing diagnostics
8124/// for those cases where they are required and determining whether the
8125/// new specialization/instantiation will have any effect.
8126///
8127/// \param NewLoc the location of the new explicit specialization or
8128/// instantiation.
8129///
8130/// \param NewTSK the kind of the new explicit specialization or instantiation.
8131///
8132/// \param PrevDecl the previous declaration of the entity.
8133///
8134/// \param PrevTSK the kind of the old explicit specialization or instantiatin.
8135///
8136/// \param PrevPointOfInstantiation if valid, indicates where the previus
8137/// declaration was instantiated (either implicitly or explicitly).
8138///
8139/// \param HasNoEffect will be set to true to indicate that the new
8140/// specialization or instantiation has no effect and should be ignored.
8141///
8142/// \returns true if there was an error that should prevent the introduction of
8143/// the new declaration into the AST, false otherwise.
8144bool
8145Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
                                           TemplateSpecializationKind NewTSK,
                                           NamedDecl *PrevDecl,
                                           TemplateSpecializationKind PrevTSK,
                                      SourceLocation PrevPointOfInstantiation,
                                           bool &HasNoEffect) {
HasNoEffect = false;

switch (NewTSK) {
case TSK_Undeclared:
case TSK_ImplicitInstantiation:
  assert((((PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation
) && "previous declaration must be implicit!") ? static_cast
<void> (0) : __assert_fail ("(PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) && \"previous declaration must be implicit!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8158, __PRETTY_FUNCTION__))
      (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&(((PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation
) && "previous declaration must be implicit!") ? static_cast
<void> (0) : __assert_fail ("(PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) && \"previous declaration must be implicit!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8158, __PRETTY_FUNCTION__))
      "previous declaration must be implicit!")(((PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation
) && "previous declaration must be implicit!") ? static_cast
<void> (0) : __assert_fail ("(PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) && \"previous declaration must be implicit!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8158, __PRETTY_FUNCTION__));
  return false;

case TSK_ExplicitSpecialization:
  switch (PrevTSK) {
  case TSK_Undeclared:
  case TSK_ExplicitSpecialization:
    // Okay, we're just specializing something that is either already
    // explicitly specialized or has merely been mentioned without any
    // instantiation.
    return false;

  case TSK_ImplicitInstantiation:
    if (PrevPointOfInstantiation.isInvalid()) {
      // The declaration itself has not actually been instantiated, so it is
      // still okay to specialize it.
      StripImplicitInstantiation(PrevDecl);
      return false;
    }
    // Fall through
    LLVM_FALLTHROUGH[[gnu::fallthrough]];

  case TSK_ExplicitInstantiationDeclaration:
  case TSK_ExplicitInstantiationDefinition:
    assert((PrevTSK == TSK_ImplicitInstantiation ||(((PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation
.isValid()) && "Explicit instantiation without point of instantiation?"
) ? static_cast<void> (0) : __assert_fail ("(PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation.isValid()) && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8184, __PRETTY_FUNCTION__))
            PrevPointOfInstantiation.isValid()) &&(((PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation
.isValid()) && "Explicit instantiation without point of instantiation?"
) ? static_cast<void> (0) : __assert_fail ("(PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation.isValid()) && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8184, __PRETTY_FUNCTION__))
           "Explicit instantiation without point of instantiation?")(((PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation
.isValid()) && "Explicit instantiation without point of instantiation?"
) ? static_cast<void> (0) : __assert_fail ("(PrevTSK == TSK_ImplicitInstantiation || PrevPointOfInstantiation.isValid()) && \"Explicit instantiation without point of instantiation?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8184, __PRETTY_FUNCTION__));

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

    Diag(NewLoc, diag::err_specialization_after_instantiation)
      << PrevDecl;
    Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
      << (PrevTSK != TSK_ImplicitInstantiation);

    return true;
  }
  llvm_unreachable("The switch over PrevTSK must be exhaustive.")::llvm::llvm_unreachable_internal("The switch over PrevTSK must be exhaustive."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8205);

case TSK_ExplicitInstantiationDeclaration:
  switch (PrevTSK) {
  case TSK_ExplicitInstantiationDeclaration:
    // This explicit instantiation declaration is redundant (that's okay).
    HasNoEffect = true;
    return false;

  case TSK_Undeclared:
  case TSK_ImplicitInstantiation:
    // We're explicitly instantiating something that may have already been
    // implicitly instantiated; that's fine.
    return false;

  case TSK_ExplicitSpecialization:
    // C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit instantiation
    //   of a template appears after a declaration of an explicit
    //   specialization for that template, the explicit instantiation has no
    //   effect.
    HasNoEffect = true;
    return false;

  case TSK_ExplicitInstantiationDefinition:
    // C++0x [temp.explicit]p10:
    //   If an entity is the subject of both an explicit instantiation
    //   declaration and an explicit instantiation definition in the same
    //   translation unit, the definition shall follow the declaration.
    Diag(NewLoc,
         diag::err_explicit_instantiation_declaration_after_definition);

    // Explicit instantiations following a specialization have no effect and
    // hence no PrevPointOfInstantiation. In that case, walk decl backwards
    // until a valid name loc is found.
    Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
         diag::note_explicit_instantiation_definition_here);
    HasNoEffect = true;
    return false;
  }
  llvm_unreachable("Unexpected TemplateSpecializationKind!")::llvm::llvm_unreachable_internal("Unexpected TemplateSpecializationKind!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8245);

case TSK_ExplicitInstantiationDefinition:
  switch (PrevTSK) {
  case TSK_Undeclared:
  case TSK_ImplicitInstantiation:
    // We're explicitly instantiating something that may have already been
    // implicitly instantiated; that's fine.
    return false;

  case TSK_ExplicitSpecialization:
    // C++ DR 259, C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit
    //   instantiation of a template appears after a declaration of
    //   an explicit specialization for that template, the explicit
    //   instantiation has no effect.
    Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
      << PrevDecl;
    Diag(PrevDecl->getLocation(),
         diag::note_previous_template_specialization);
    HasNoEffect = true;
    return false;

  case TSK_ExplicitInstantiationDeclaration:
    // We're explicitly instantiating a definition for something for which we
    // were previously asked to suppress instantiations. That's fine.

    // C++0x [temp.explicit]p4:
    //   For a given set of template parameters, if an explicit instantiation
    //   of a template appears after a declaration of an explicit
    //   specialization for that template, the explicit instantiation has no
    //   effect.
    for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
      // Is there any previous explicit specialization declaration?
      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
        HasNoEffect = true;
        break;
      }
    }

    return false;

  case TSK_ExplicitInstantiationDefinition:
    // C++0x [temp.spec]p5:
    //   For a given template and a given set of template-arguments,
    //     - an explicit instantiation definition shall appear at most once
    //       in a program,

    // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
    Diag(NewLoc, (getLangOpts().MSVCCompat)
                     ? diag::ext_explicit_instantiation_duplicate
                     : diag::err_explicit_instantiation_duplicate)
        << PrevDecl;
    Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
         diag::note_previous_explicit_instantiation);
    HasNoEffect = true;
    return false;
  }
}

llvm_unreachable("Missing specialization/instantiation case?")::llvm::llvm_unreachable_internal("Missing specialization/instantiation case?"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8305);
8306}

8308/// Perform semantic analysis for the given dependent function
8309/// template specialization.
8310///
8311/// The only possible way to get a dependent function template specialization
8312/// is with a friend declaration, like so:
8313///
8314/// \code
8315///   template \<class T> void foo(T);
8316///   template \<class T> class A {
8317///     friend void foo<>(T);
8318///   };
8319/// \endcode
8320///
8321/// There really isn't any useful analysis we can do here, so we
8322/// just store the information.
8323bool
8324Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
                 const TemplateArgumentListInfo &ExplicitTemplateArgs,
                                                 LookupResult &Previous) {
// Remove anything from Previous that isn't a function template in
// the correct context.
DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
LookupResult::Filter F = Previous.makeFilter();
enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
SmallVector<std::pair<DiscardReason, Decl *>, 8> DiscardedCandidates;
while (F.hasNext()) {
  NamedDecl *D = F.next()->getUnderlyingDecl();
  if (!isa<FunctionTemplateDecl>(D)) {
    F.erase();
    DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate, D));
    continue;
  }

  if (!FDLookupContext->InEnclosingNamespaceSetOf(
          D->getDeclContext()->getRedeclContext())) {
    F.erase();
    DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing, D));
    continue;
  }
}
F.done();

if (Previous.empty()) {
  Diag(FD->getLocation(),
       diag::err_dependent_function_template_spec_no_match);
  for (auto &P : DiscardedCandidates)
    Diag(P.second->getLocation(),
         diag::note_dependent_function_template_spec_discard_reason)
        << P.first;
  return true;
}

FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
                                       ExplicitTemplateArgs);
return false;
8363}

8365/// Perform semantic analysis for the given function template
8366/// specialization.
8367///
8368/// This routine performs all of the semantic analysis required for an
8369/// explicit function template specialization. On successful completion,
8370/// the function declaration \p FD will become a function template
8371/// specialization.
8372///
8373/// \param FD the function declaration, which will be updated to become a
8374/// function template specialization.
8375///
8376/// \param ExplicitTemplateArgs the explicitly-provided template arguments,
8377/// if any. Note that this may be valid info even when 0 arguments are
8378/// explicitly provided as in, e.g., \c void sort<>(char*, char*);
8379/// as it anyway contains info on the angle brackets locations.
8380///
8381/// \param Previous the set of declarations that may be specialized by
8382/// this function specialization.
8383///
8384/// \param QualifiedFriend whether this is a lookup for a qualified friend
8385/// declaration with no explicit template argument list that might be
8386/// befriending a function template specialization.
8387bool Sema::CheckFunctionTemplateSpecialization(
  FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
  LookupResult &Previous, bool QualifiedFriend) {
// The set of function template specializations that could match this
// explicit function template specialization.
UnresolvedSet<8> Candidates;
TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
                                          /*ForTakingAddress=*/false);

llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
    ConvertedTemplateArgs;

DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
       I != E; ++I) {
  NamedDecl *Ovl = (*I)->getUnderlyingDecl();
  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
    // Only consider templates found within the same semantic lookup scope as
    // FD.
    if (!FDLookupContext->InEnclosingNamespaceSetOf(
                              Ovl->getDeclContext()->getRedeclContext()))
      continue;

    // When matching a constexpr member function template specialization
    // against the primary template, we don't yet know whether the
    // specialization has an implicit 'const' (because we don't know whether
    // it will be a static member function until we know which template it
    // specializes), so adjust it now assuming it specializes this template.
    QualType FT = FD->getType();
    if (FD->isConstexpr()) {
      CXXMethodDecl *OldMD =
        dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
      if (OldMD && OldMD->isConst()) {
        const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
        FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
        EPI.TypeQuals.addConst();
        FT = Context.getFunctionType(FPT->getReturnType(),
                                     FPT->getParamTypes(), EPI);
      }
    }

    TemplateArgumentListInfo Args;
    if (ExplicitTemplateArgs)
      Args = *ExplicitTemplateArgs;

    // C++ [temp.expl.spec]p11:
    //   A trailing template-argument can be left unspecified in the
    //   template-id naming an explicit function template specialization
    //   provided it can be deduced from the function argument type.
    // Perform template argument deduction to determine whether we may be
    // specializing this template.
    // FIXME: It is somewhat wasteful to build
    TemplateDeductionInfo Info(FailedCandidates.getLocation());
    FunctionDecl *Specialization = nullptr;
    if (TemplateDeductionResult TDK = DeduceTemplateArguments(
            cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
            ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
            Info)) {
      // Template argument deduction failed; record why it failed, so
      // that we can provide nifty diagnostics.
      FailedCandidates.addCandidate().set(
          I.getPair(), FunTmpl->getTemplatedDecl(),
          MakeDeductionFailureInfo(Context, TDK, Info));
      (void)TDK;
      continue;
    }

    // Target attributes are part of the cuda function signature, so
    // the deduced template's cuda target must match that of the
    // specialization.  Given that C++ template deduction does not
    // take target attributes into account, we reject candidates
    // here that have a different target.
    if (LangOpts.CUDA &&
        IdentifyCUDATarget(Specialization,
                           /* IgnoreImplicitHDAttr = */ true) !=
            IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttr = */ true)) {
      FailedCandidates.addCandidate().set(
          I.getPair(), FunTmpl->getTemplatedDecl(),
          MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
      continue;
    }

    // Record this candidate.
    if (ExplicitTemplateArgs)
      ConvertedTemplateArgs[Specialization] = std::move(Args);
    Candidates.addDecl(Specialization, I.getAccess());
  }
}

// For a qualified friend declaration (with no explicit marker to indicate
// that a template specialization was intended), note all (template and
// non-template) candidates.
if (QualifiedFriend && Candidates.empty()) {
  Diag(FD->getLocation(), diag::err_qualified_friend_no_match)
      << FD->getDeclName() << FDLookupContext;
  // FIXME: We should form a single candidate list and diagnose all
  // candidates at once, to get proper sorting and limiting.
  for (auto *OldND : Previous) {
    if (auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
      NoteOverloadCandidate(OldND, OldFD, FD->getType(), false);
  }
  FailedCandidates.NoteCandidates(*this, FD->getLocation());
  return true;
}

// Find the most specialized function template.
UnresolvedSetIterator Result = getMostSpecialized(
    Candidates.begin(), Candidates.end(), FailedCandidates, FD->getLocation(),
    PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
    PDiag(diag::err_function_template_spec_ambiguous)
        << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
    PDiag(diag::note_function_template_spec_matched));

if (Result == Candidates.end())
  return true;

// Ignore access information;  it doesn't figure into redeclaration checking.
FunctionDecl *Specialization = cast<FunctionDecl>(*Result);

FunctionTemplateSpecializationInfo *SpecInfo
  = Specialization->getTemplateSpecializationInfo();
assert(SpecInfo && "Function template specialization info missing?")((SpecInfo && "Function template specialization info missing?"
) ? static_cast<void> (0) : __assert_fail ("SpecInfo && \"Function template specialization info missing?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8508, __PRETTY_FUNCTION__));

// Note: do not overwrite location info if previous template
// specialization kind was explicit.
TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
  Specialization->setLocation(FD->getLocation());
  Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
  // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
  // function can differ from the template declaration with respect to
  // the constexpr specifier.
  // FIXME: We need an update record for this AST mutation.
  // FIXME: What if there are multiple such prior declarations (for instance,
  // from different modules)?
  Specialization->setConstexprKind(FD->getConstexprKind());
}

// FIXME: Check if the prior specialization has a point of instantiation.
// If so, we have run afoul of .

// If this is a friend declaration, then we're not really declaring
// an explicit specialization.
bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);

// Check the scope of this explicit specialization.
if (!isFriend &&
    CheckTemplateSpecializationScope(*this,
                                     Specialization->getPrimaryTemplate(),
                                     Specialization, FD->getLocation(),
                                     false))
  return true;

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
bool HasNoEffect = false;
if (!isFriend &&
    CheckSpecializationInstantiationRedecl(FD->getLocation(),
                                           TSK_ExplicitSpecialization,
                                           Specialization,
                                 SpecInfo->getTemplateSpecializationKind(),
                                       SpecInfo->getPointOfInstantiation(),
                                           HasNoEffect))
  return true;

// Mark the prior declaration as an explicit specialization, so that later
// clients know that this is an explicit specialization.
if (!isFriend) {
  // Since explicit specializations do not inherit '=delete' from their
  // primary function template - check if the 'specialization' that was
  // implicitly generated (during template argument deduction for partial
  // ordering) from the most specialized of all the function templates that
  // 'FD' could have been specializing, has a 'deleted' definition.  If so,
  // first check that it was implicitly generated during template argument
  // deduction by making sure it wasn't referenced, and then reset the deleted
  // flag to not-deleted, so that we can inherit that information from 'FD'.
  if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
      !Specialization->getCanonicalDecl()->isReferenced()) {
    // FIXME: This assert will not hold in the presence of modules.
    assert(((Specialization->getCanonicalDecl() == Specialization &&
 "This must be the only existing declaration of this specialization"
) ? static_cast<void> (0) : __assert_fail ("Specialization->getCanonicalDecl() == Specialization && \"This must be the only existing declaration of this specialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8572, __PRETTY_FUNCTION__))
        Specialization->getCanonicalDecl() == Specialization &&((Specialization->getCanonicalDecl() == Specialization &&
 "This must be the only existing declaration of this specialization"
) ? static_cast<void> (0) : __assert_fail ("Specialization->getCanonicalDecl() == Specialization && \"This must be the only existing declaration of this specialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8572, __PRETTY_FUNCTION__))
        "This must be the only existing declaration of this specialization")((Specialization->getCanonicalDecl() == Specialization &&
 "This must be the only existing declaration of this specialization"
) ? static_cast<void> (0) : __assert_fail ("Specialization->getCanonicalDecl() == Specialization && \"This must be the only existing declaration of this specialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8572, __PRETTY_FUNCTION__));
    // FIXME: We need an update record for this AST mutation.
    Specialization->setDeletedAsWritten(false);
  }
  // FIXME: We need an update record for this AST mutation.
  SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
  MarkUnusedFileScopedDecl(Specialization);
}

// Turn the given function declaration into a function template
// specialization, with the template arguments from the previous
// specialization.
// Take copies of (semantic and syntactic) template argument lists.
const TemplateArgumentList* TemplArgs = new (Context)
  TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
FD->setFunctionTemplateSpecialization(
    Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
    SpecInfo->getTemplateSpecializationKind(),
    ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);

// A function template specialization inherits the target attributes
// of its template.  (We require the attributes explicitly in the
// code to match, but a template may have implicit attributes by
// virtue e.g. of being constexpr, and it passes these implicit
// attributes on to its specializations.)
if (LangOpts.CUDA)
  inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());

// The "previous declaration" for this function template specialization is
// the prior function template specialization.
Previous.clear();
Previous.addDecl(Specialization);
return false;
8605}

8607/// Perform semantic analysis for the given non-template member
8608/// specialization.
8609///
8610/// This routine performs all of the semantic analysis required for an
8611/// explicit member function specialization. On successful completion,
8612/// the function declaration \p FD will become a member function
8613/// specialization.
8614///
8615/// \param Member the member declaration, which will be updated to become a
8616/// specialization.
8617///
8618/// \param Previous the set of declarations, one of which may be specialized
8619/// by this function specialization;  the set will be modified to contain the
8620/// redeclared member.
8621bool
8622Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) {
assert(!isa<TemplateDecl>(Member) && "Only for non-template members")((!isa<TemplateDecl>(Member) && "Only for non-template members"
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateDecl>(Member) && \"Only for non-template members\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8623, __PRETTY_FUNCTION__));

// Try to find the member we are instantiating.
NamedDecl *FoundInstantiation = nullptr;
NamedDecl *Instantiation = nullptr;
NamedDecl *InstantiatedFrom = nullptr;
MemberSpecializationInfo *MSInfo = nullptr;

if (Previous.empty()) {
  // Nowhere to look anyway.
} else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
         I != E; ++I) {
    NamedDecl *D = (*I)->getUnderlyingDecl();
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
      QualType Adjusted = Function->getType();
      if (!hasExplicitCallingConv(Adjusted))
        Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
      // This doesn't handle deduced return types, but both function
      // declarations should be undeduced at this point.
      if (Context.hasSameType(Adjusted, Method->getType())) {
        FoundInstantiation = *I;
        Instantiation = Method;
        InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
        MSInfo = Method->getMemberSpecializationInfo();
        break;
      }
    }
  }
} else if (isa<VarDecl>(Member)) {
  VarDecl *PrevVar;
  if (Previous.isSingleResult() &&
      (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
    if (PrevVar->isStaticDataMember()) {
      FoundInstantiation = Previous.getRepresentativeDecl();
      Instantiation = PrevVar;
      InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
      MSInfo = PrevVar->getMemberSpecializationInfo();
    }
} else if (isa<RecordDecl>(Member)) {
  CXXRecordDecl *PrevRecord;
  if (Previous.isSingleResult() &&
      (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
    FoundInstantiation = Previous.getRepresentativeDecl();
    Instantiation = PrevRecord;
    InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
    MSInfo = PrevRecord->getMemberSpecializationInfo();
  }
} else if (isa<EnumDecl>(Member)) {
  EnumDecl *PrevEnum;
  if (Previous.isSingleResult() &&
      (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
    FoundInstantiation = Previous.getRepresentativeDecl();
    Instantiation = PrevEnum;
    InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
    MSInfo = PrevEnum->getMemberSpecializationInfo();
  }
}

if (!Instantiation) {
  // There is no previous declaration that matches. Since member
  // specializations are always out-of-line, the caller will complain about
  // this mismatch later.
  return false;
}

// A member specialization in a friend declaration isn't really declaring
// an explicit specialization, just identifying a specific (possibly implicit)
// specialization. Don't change the template specialization kind.
//
// FIXME: Is this really valid? Other compilers reject.
if (Member->getFriendObjectKind() != Decl::FOK_None) {
  // Preserve instantiation information.
  if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
    cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
                                    cast<CXXMethodDecl>(InstantiatedFrom),
      cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
  } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
    cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
                                    cast<CXXRecordDecl>(InstantiatedFrom),
      cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
  }

  Previous.clear();
  Previous.addDecl(FoundInstantiation);
  return false;
}

// Make sure that this is a specialization of a member.
if (!InstantiatedFrom) {
  Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
    << Member;
  Diag(Instantiation->getLocation(), diag::note_specialized_decl);
  return true;
}

// C++ [temp.expl.spec]p6:
//   If a template, a member template or the member of a class template is
//   explicitly specialized then that specialization shall be declared
//   before the first use of that specialization that would cause an implicit
//   instantiation to take place, in every translation unit in which such a
//   use occurs; no diagnostic is required.
assert(MSInfo && "Member specialization info missing?")((MSInfo && "Member specialization info missing?") ? static_cast
<void> (0) : __assert_fail ("MSInfo && \"Member specialization info missing?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8725, __PRETTY_FUNCTION__));

bool HasNoEffect = false;
if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
                                           TSK_ExplicitSpecialization,
                                           Instantiation,
                                   MSInfo->getTemplateSpecializationKind(),
                                         MSInfo->getPointOfInstantiation(),
                                           HasNoEffect))
  return true;

// Check the scope of this explicit specialization.
if (CheckTemplateSpecializationScope(*this,
                                     InstantiatedFrom,
                                     Instantiation, Member->getLocation(),
                                     false))
  return true;

// Note that this member specialization is an "instantiation of" the
// corresponding member of the original template.
if (auto *MemberFunction = dyn_cast<FunctionDecl>(Member)) {
  FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
  if (InstantiationFunction->getTemplateSpecializationKind() ==
        TSK_ImplicitInstantiation) {
    // Explicit specializations of member functions of class templates do not
    // inherit '=delete' from the member function they are specializing.
    if (InstantiationFunction->isDeleted()) {
      // FIXME: This assert will not hold in the presence of modules.
      assert(InstantiationFunction->getCanonicalDecl() ==((InstantiationFunction->getCanonicalDecl() == InstantiationFunction
) ? static_cast<void> (0) : __assert_fail ("InstantiationFunction->getCanonicalDecl() == InstantiationFunction"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8754, __PRETTY_FUNCTION__))
             InstantiationFunction)((InstantiationFunction->getCanonicalDecl() == InstantiationFunction
) ? static_cast<void> (0) : __assert_fail ("InstantiationFunction->getCanonicalDecl() == InstantiationFunction"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8754, __PRETTY_FUNCTION__));
      // FIXME: We need an update record for this AST mutation.
      InstantiationFunction->setDeletedAsWritten(false);
    }
  }

  MemberFunction->setInstantiationOfMemberFunction(
      cast<CXXMethodDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberVar = dyn_cast<VarDecl>(Member)) {
  MemberVar->setInstantiationOfStaticDataMember(
      cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberClass = dyn_cast<CXXRecordDecl>(Member)) {
  MemberClass->setInstantiationOfMemberClass(
      cast<CXXRecordDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else if (auto *MemberEnum = dyn_cast<EnumDecl>(Member)) {
  MemberEnum->setInstantiationOfMemberEnum(
      cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
} else {
  llvm_unreachable("unknown member specialization kind")::llvm::llvm_unreachable_internal("unknown member specialization kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8772);
}

// Save the caller the trouble of having to figure out which declaration
// this specialization matches.
Previous.clear();
Previous.addDecl(FoundInstantiation);
return false;
8780}

8782/// Complete the explicit specialization of a member of a class template by
8783/// updating the instantiated member to be marked as an explicit specialization.
8784///
8785/// \param OrigD The member declaration instantiated from the template.
8786/// \param Loc The location of the explicit specialization of the member.
8787template<typename DeclT>
8788static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD,
                                           SourceLocation Loc) {
if (OrigD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
  return;

// FIXME: Inform AST mutation listeners of this AST mutation.
// FIXME: If there are multiple in-class declarations of the member (from
// multiple modules, or a declaration and later definition of a member type),
// should we update all of them?
OrigD->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
OrigD->setLocation(Loc);
8799}

8801void Sema::CompleteMemberSpecialization(NamedDecl *Member,
                                      LookupResult &Previous) {
NamedDecl *Instantiation = cast<NamedDecl>(Member->getCanonicalDecl());
if (Instantiation == Member)
  return;

if (auto *Function = dyn_cast<CXXMethodDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Function, Member->getLocation());
else if (auto *Var = dyn_cast<VarDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Var, Member->getLocation());
else if (auto *Record = dyn_cast<CXXRecordDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Record, Member->getLocation());
else if (auto *Enum = dyn_cast<EnumDecl>(Instantiation))
  completeMemberSpecializationImpl(*this, Enum, Member->getLocation());
else
  llvm_unreachable("unknown member specialization kind")::llvm::llvm_unreachable_internal("unknown member specialization kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8816);
8817}

8819/// Check the scope of an explicit instantiation.
8820///
8821/// \returns true if a serious error occurs, false otherwise.
8822static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D,
                                          SourceLocation InstLoc,
                                          bool WasQualifiedName) {
DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
DeclContext *CurContext = S.CurContext->getRedeclContext();

if (CurContext->isRecord()) {
  S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
    << D;
  return true;
}

// C++11 [temp.explicit]p3:
//   An explicit instantiation shall appear in an enclosing namespace of its
//   template. If the name declared in the explicit instantiation is an
//   unqualified name, the explicit instantiation shall appear in the
//   namespace where its template is declared or, if that namespace is inline
//   (7.3.1), any namespace from its enclosing namespace set.
//
// This is DR275, which we do not retroactively apply to C++98/03.
if (WasQualifiedName) {
  if (CurContext->Encloses(OrigContext))
    return false;
} else {
  if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
    return false;
}

if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
  if (WasQualifiedName)
    S.Diag(InstLoc,
           S.getLangOpts().CPlusPlus11?
             diag::err_explicit_instantiation_out_of_scope :
             diag::warn_explicit_instantiation_out_of_scope_0x)
      << D << NS;
  else
    S.Diag(InstLoc,
           S.getLangOpts().CPlusPlus11?
             diag::err_explicit_instantiation_unqualified_wrong_namespace :
             diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
      << D << NS;
} else
  S.Diag(InstLoc,
         S.getLangOpts().CPlusPlus11?
           diag::err_explicit_instantiation_must_be_global :
           diag::warn_explicit_instantiation_must_be_global_0x)
    << D;
S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
return false;
8871}

8873/// Common checks for whether an explicit instantiation of \p D is valid.
8874static bool CheckExplicitInstantiation(Sema &S, NamedDecl *D,
                                     SourceLocation InstLoc,
                                     bool WasQualifiedName,
                                     TemplateSpecializationKind TSK) {
// C++ [temp.explicit]p13:
//   An explicit instantiation declaration shall not name a specialization of
//   a template with internal linkage.
if (TSK == TSK_ExplicitInstantiationDeclaration &&
    D->getFormalLinkage() == InternalLinkage) {
  S.Diag(InstLoc, diag::err_explicit_instantiation_internal_linkage) << D;
  return true;
}

// C++11 [temp.explicit]p3: [DR 275]
//   An explicit instantiation shall appear in an enclosing namespace of its
//   template.
if (CheckExplicitInstantiationScope(S, D, InstLoc, WasQualifiedName))
  return true;

return false;
8894}

8896/// Determine whether the given scope specifier has a template-id in it.
8897static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) {
if (!SS.isSet())
  return false;

// C++11 [temp.explicit]p3:
//   If the explicit instantiation is for a member function, a member class
//   or a static data member of a class template specialization, the name of
//   the class template specialization in the qualified-id for the member
//   name shall be a simple-template-id.
//
// C++98 has the same restriction, just worded differently.
for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
     NNS = NNS->getPrefix())
  if (const Type *T = NNS->getAsType())
    if (isa<TemplateSpecializationType>(T))
      return true;

return false;
8915}

8917/// Make a dllexport or dllimport attr on a class template specialization take
8918/// effect.
8919static void dllExportImportClassTemplateSpecialization(
  Sema &S, ClassTemplateSpecializationDecl *Def) {
auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
assert(A && "dllExportImportClassTemplateSpecialization called "((A && "dllExportImportClassTemplateSpecialization called "
 "on Def without dllexport or dllimport") ? static_cast<void
> (0) : __assert_fail ("A && \"dllExportImportClassTemplateSpecialization called \" \"on Def without dllexport or dllimport\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8923, __PRETTY_FUNCTION__))
            "on Def without dllexport or dllimport")((A && "dllExportImportClassTemplateSpecialization called "
 "on Def without dllexport or dllimport") ? static_cast<void
> (0) : __assert_fail ("A && \"dllExportImportClassTemplateSpecialization called \" \"on Def without dllexport or dllimport\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8923, __PRETTY_FUNCTION__));

// We reject explicit instantiations in class scope, so there should
// never be any delayed exported classes to worry about.
assert(S.DelayedDllExportClasses.empty() &&((S.DelayedDllExportClasses.empty() && "delayed exports present at explicit instantiation"
) ? static_cast<void> (0) : __assert_fail ("S.DelayedDllExportClasses.empty() && \"delayed exports present at explicit instantiation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8928, __PRETTY_FUNCTION__))
       "delayed exports present at explicit instantiation")((S.DelayedDllExportClasses.empty() && "delayed exports present at explicit instantiation"
) ? static_cast<void> (0) : __assert_fail ("S.DelayedDllExportClasses.empty() && \"delayed exports present at explicit instantiation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8928, __PRETTY_FUNCTION__));
S.checkClassLevelDLLAttribute(Def);

// Propagate attribute to base class templates.
for (auto &B : Def->bases()) {
  if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
          B.getType()->getAsCXXRecordDecl()))
    S.propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getBeginLoc());
}

S.referenceDLLExportedClassMethods();
8939}

8941// Explicit instantiation of a class template specialization
8942DeclResult Sema::ActOnExplicitInstantiation(
  Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
  unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
  TemplateTy TemplateD, SourceLocation TemplateNameLoc,
  SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn,
  SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {
// Find the class template we're specializing
TemplateName Name = TemplateD.get();
TemplateDecl *TD = Name.getAsTemplateDecl();
// Check that the specialization uses the same tag kind as the
// original template.
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
assert(Kind != TTK_Enum &&((Kind != TTK_Enum && "Invalid enum tag in class template explicit instantiation!"
) ? static_cast<void> (0) : __assert_fail ("Kind != TTK_Enum && \"Invalid enum tag in class template explicit instantiation!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8955, __PRETTY_FUNCTION__))
       "Invalid enum tag in class template explicit instantiation!")((Kind != TTK_Enum && "Invalid enum tag in class template explicit instantiation!"
) ? static_cast<void> (0) : __assert_fail ("Kind != TTK_Enum && \"Invalid enum tag in class template explicit instantiation!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 8955, __PRETTY_FUNCTION__));

ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);

if (!ClassTemplate) {
  NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
  Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
  Diag(TD->getLocation(), diag::note_previous_use);
  return true;
}

if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
                                  Kind, /*isDefinition*/false, KWLoc,
                                  ClassTemplate->getIdentifier())) {
  Diag(KWLoc, diag::err_use_with_wrong_tag)
    << ClassTemplate
    << FixItHint::CreateReplacement(KWLoc,
                          ClassTemplate->getTemplatedDecl()->getKindName());
  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
       diag::note_previous_use);
  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
}

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK = ExternLoc.isInvalid()
                                     ? TSK_ExplicitInstantiationDefinition
                                     : TSK_ExplicitInstantiationDeclaration;

if (TSK == TSK_ExplicitInstantiationDeclaration &&
    !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
  // Check for dllexport class template instantiation declarations,
  // except for MinGW mode.
  for (const ParsedAttr &AL : Attr) {
    if (AL.getKind() == ParsedAttr::AT_DLLExport) {
      Diag(ExternLoc,
           diag::warn_attribute_dllexport_explicit_instantiation_decl);
      Diag(AL.getLoc(), diag::note_attribute);
      break;
    }
  }

  if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
    Diag(ExternLoc,
         diag::warn_attribute_dllexport_explicit_instantiation_decl);
    Diag(A->getLocation(), diag::note_attribute);
  }
}

// In MSVC mode, dllimported explicit instantiation definitions are treated as
// instantiation declarations for most purposes.
bool DLLImportExplicitInstantiationDef = false;
if (TSK == TSK_ExplicitInstantiationDefinition &&
    Context.getTargetInfo().getCXXABI().isMicrosoft()) {
  // Check for dllimport class template instantiation definitions.
  bool DLLImport =
      ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
  for (const ParsedAttr &AL : Attr) {
    if (AL.getKind() == ParsedAttr::AT_DLLImport)
      DLLImport = true;
    if (AL.getKind() == ParsedAttr::AT_DLLExport) {
      // dllexport trumps dllimport here.
      DLLImport = false;
      break;
    }
  }
  if (DLLImport) {
    TSK = TSK_ExplicitInstantiationDeclaration;
    DLLImportExplicitInstantiationDef = true;
  }
}

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

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

// Find the class template specialization declaration that
// corresponds to these arguments.
void *InsertPos = nullptr;
ClassTemplateSpecializationDecl *PrevDecl
  = ClassTemplate->findSpecialization(Converted, InsertPos);

TemplateSpecializationKind PrevDecl_TSK
  = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;

if (TSK == TSK_ExplicitInstantiationDefinition && PrevDecl != nullptr &&
    Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
  // Check for dllexport class template instantiation definitions in MinGW
  // mode, if a previous declaration of the instantiation was seen.
  for (const ParsedAttr &AL : Attr) {
    if (AL.getKind() == ParsedAttr::AT_DLLExport) {
      Diag(AL.getLoc(),
           diag::warn_attribute_dllexport_explicit_instantiation_def);
      break;
    }
  }
}

if (CheckExplicitInstantiation(*this, ClassTemplate, TemplateNameLoc,
                               SS.isSet(), TSK))
  return true;

ClassTemplateSpecializationDecl *Specialization = nullptr;

bool HasNoEffect = false;
if (PrevDecl) {
  if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
                                             PrevDecl, PrevDecl_TSK,
                                          PrevDecl->getPointOfInstantiation(),
                                             HasNoEffect))
    return PrevDecl;

  // Even though HasNoEffect == true means that this explicit instantiation
  // has no effect on semantics, we go on to put its syntax in the AST.

  if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
      PrevDecl_TSK == TSK_Undeclared) {
    // Since the only prior class template specialization with these
    // arguments was referenced but not declared, reuse that
    // declaration node as our own, updating the source location
    // for the template name to reflect our new declaration.
    // (Other source locations will be updated later.)
    Specialization = PrevDecl;
    Specialization->setLocation(TemplateNameLoc);
    PrevDecl = nullptr;
  }

  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
      DLLImportExplicitInstantiationDef) {
    // The new specialization might add a dllimport attribute.
    HasNoEffect = false;
  }
}

if (!Specialization) {
  // Create a new class template specialization declaration node for
  // this explicit specialization.
  Specialization
    = ClassTemplateSpecializationDecl::Create(Context, Kind,
                                           ClassTemplate->getDeclContext(),
                                              KWLoc, TemplateNameLoc,
                                              ClassTemplate,
                                              Converted,
                                              PrevDecl);
  SetNestedNameSpecifier(*this, Specialization, SS);

  if (!HasNoEffect && !PrevDecl) {
    // Insert the new specialization.
    ClassTemplate->AddSpecialization(Specialization, InsertPos);
  }
}

// Build the fully-sugared type for this explicit instantiation as
// the user wrote in the explicit instantiation itself. This means
// that we'll pretty-print the type retrieved from the
// specialization's declaration the way that the user actually wrote
// the explicit instantiation, rather than formatting the name based
// on the "canonical" representation used to store the template
// arguments in the specialization.
TypeSourceInfo *WrittenTy
  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
                                              TemplateArgs,
                                Context.getTypeDeclType(Specialization));
Specialization->setTypeAsWritten(WrittenTy);

// Set source locations for keywords.
Specialization->setExternLoc(ExternLoc);
Specialization->setTemplateKeywordLoc(TemplateLoc);
Specialization->setBraceRange(SourceRange());

bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
ProcessDeclAttributeList(S, Specialization, Attr);

// Add the explicit instantiation into its lexical context. However,
// since explicit instantiations are never found by name lookup, we
// just put it into the declaration context directly.
Specialization->setLexicalDeclContext(CurContext);
CurContext->addDecl(Specialization);

// Syntax is now OK, so return if it has no other effect on semantics.
if (HasNoEffect) {
  // Set the template specialization kind.
  Specialization->setTemplateSpecializationKind(TSK);
  return Specialization;
}

// C++ [temp.explicit]p3:
//   A definition of a class template or class member template
//   shall be in scope at the point of the explicit instantiation of
//   the class template or class member template.
//
// This check comes when we actually try to perform the
// instantiation.
ClassTemplateSpecializationDecl *Def
  = cast_or_null<ClassTemplateSpecializationDecl>(
                                            Specialization->getDefinition());
if (!Def)
  InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
else if (TSK == TSK_ExplicitInstantiationDefinition) {
  MarkVTableUsed(TemplateNameLoc, Specialization, true);
  Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
}

// Instantiate the members of this class template specialization.
Def = cast_or_null<ClassTemplateSpecializationDecl>(
                                     Specialization->getDefinition());
if (Def) {
  TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind();
  // Fix a TSK_ExplicitInstantiationDeclaration followed by a
  // TSK_ExplicitInstantiationDefinition
  if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
      (TSK == TSK_ExplicitInstantiationDefinition ||
       DLLImportExplicitInstantiationDef)) {
    // FIXME: Need to notify the ASTMutationListener that we did this.
    Def->setTemplateSpecializationKind(TSK);

    if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
        (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
         Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
      // In the MS ABI, an explicit instantiation definition can add a dll
      // attribute to a template with a previous instantiation declaration.
      // MinGW doesn't allow this.
      auto *A = cast<InheritableAttr>(
          getDLLAttr(Specialization)->clone(getASTContext()));
      A->setInherited(true);
      Def->addAttr(A);
      dllExportImportClassTemplateSpecialization(*this, Def);
    }
  }

  // Fix a TSK_ImplicitInstantiation followed by a
  // TSK_ExplicitInstantiationDefinition
  bool NewlyDLLExported =
      !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
  if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
      (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
       Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
    // In the MS ABI, an explicit instantiation definition can add a dll
    // attribute to a template with a previous implicit instantiation.
    // MinGW doesn't allow this. We limit clang to only adding dllexport, to
    // avoid potentially strange codegen behavior.  For example, if we extend
    // this conditional to dllimport, and we have a source file calling a
    // method on an implicitly instantiated template class instance and then
    // declaring a dllimport explicit instantiation definition for the same
    // template class, the codegen for the method call will not respect the
    // dllimport, while it will with cl. The Def will already have the DLL
    // attribute, since the Def and Specialization will be the same in the
    // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
    // attribute to the Specialization; we just need to make it take effect.
    assert(Def == Specialization &&((Def == Specialization && "Def and Specialization should match for implicit instantiation"
) ? static_cast<void> (0) : __assert_fail ("Def == Specialization && \"Def and Specialization should match for implicit instantiation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9214, __PRETTY_FUNCTION__))
           "Def and Specialization should match for implicit instantiation")((Def == Specialization && "Def and Specialization should match for implicit instantiation"
) ? static_cast<void> (0) : __assert_fail ("Def == Specialization && \"Def and Specialization should match for implicit instantiation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9214, __PRETTY_FUNCTION__));
    dllExportImportClassTemplateSpecialization(*this, Def);
  }

  // In MinGW mode, export the template instantiation if the declaration
  // was marked dllexport.
  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
      Context.getTargetInfo().getTriple().isWindowsGNUEnvironment() &&
      PrevDecl->hasAttr<DLLExportAttr>()) {
    dllExportImportClassTemplateSpecialization(*this, Def);
  }

  // Set the template specialization kind. Make sure it is set before
  // instantiating the members which will trigger ASTConsumer callbacks.
  Specialization->setTemplateSpecializationKind(TSK);
  InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
} else {

  // Set the template specialization kind.
  Specialization->setTemplateSpecializationKind(TSK);
}

return Specialization;
9237}

9239// Explicit instantiation of a member class of a class template.
9240DeclResult
9241Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
                               SourceLocation TemplateLoc, unsigned TagSpec,
                               SourceLocation KWLoc, CXXScopeSpec &SS,
                               IdentifierInfo *Name, SourceLocation NameLoc,
                               const ParsedAttributesView &Attr) {

bool Owned = false;
bool IsDependent = false;
Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
                      KWLoc, SS, Name, NameLoc, Attr, AS_none,
                      /*ModulePrivateLoc=*/SourceLocation(),
                      MultiTemplateParamsArg(), Owned, IsDependent,
                      SourceLocation(), false, TypeResult(),
                      /*IsTypeSpecifier*/false,
                      /*IsTemplateParamOrArg*/false);
assert(!IsDependent && "explicit instantiation of dependent name not yet handled")((!IsDependent && "explicit instantiation of dependent name not yet handled"
) ? static_cast<void> (0) : __assert_fail ("!IsDependent && \"explicit instantiation of dependent name not yet handled\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9256, __PRETTY_FUNCTION__));

if (!TagD)
  return true;

TagDecl *Tag = cast<TagDecl>(TagD);
assert(!Tag->isEnum() && "shouldn't see enumerations here")((!Tag->isEnum() && "shouldn't see enumerations here"
) ? static_cast<void> (0) : __assert_fail ("!Tag->isEnum() && \"shouldn't see enumerations here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9262, __PRETTY_FUNCTION__));

if (Tag->isInvalidDecl())
  return true;

CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
if (!Pattern) {
  Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
    << Context.getTypeDeclType(Record);
  Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
  return true;
}

// C++0x [temp.explicit]p2:
//   If the explicit instantiation is for a class or member class, the
//   elaborated-type-specifier in the declaration shall include a
//   simple-template-id.
//
// C++98 has the same restriction, just worded differently.
if (!ScopeSpecifierHasTemplateId(SS))
  Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
    << Record << SS.getRange();

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK
  = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                         : TSK_ExplicitInstantiationDeclaration;

CheckExplicitInstantiation(*this, Record, NameLoc, true, TSK);

// Verify that it is okay to explicitly instantiate here.
CXXRecordDecl *PrevDecl
  = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
if (!PrevDecl && Record->getDefinition())
  PrevDecl = Record;
if (PrevDecl) {
  MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo();
  bool HasNoEffect = false;
  assert(MSInfo && "No member specialization information?")((MSInfo && "No member specialization information?") ?
 static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9304, __PRETTY_FUNCTION__));
  if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
                                             PrevDecl,
                                      MSInfo->getTemplateSpecializationKind(),
                                           MSInfo->getPointOfInstantiation(),
                                             HasNoEffect))
    return true;
  if (HasNoEffect)
    return TagD;
}

CXXRecordDecl *RecordDef
  = cast_or_null<CXXRecordDecl>(Record->getDefinition());
if (!RecordDef) {
  // C++ [temp.explicit]p3:
  //   A definition of a member class of a class template shall be in scope
  //   at the point of an explicit instantiation of the member class.
  CXXRecordDecl *Def
    = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
  if (!Def) {
    Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
      << 0 << Record->getDeclName() << Record->getDeclContext();
    Diag(Pattern->getLocation(), diag::note_forward_declaration)
      << Pattern;
    return true;
  } else {
    if (InstantiateClass(NameLoc, Record, Def,
                         getTemplateInstantiationArgs(Record),
                         TSK))
      return true;

    RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
    if (!RecordDef)
      return true;
  }
}

// Instantiate all of the members of the class.
InstantiateClassMembers(NameLoc, RecordDef,
                        getTemplateInstantiationArgs(Record), TSK);

if (TSK == TSK_ExplicitInstantiationDefinition)
  MarkVTableUsed(NameLoc, RecordDef, true);

// FIXME: We don't have any representation for explicit instantiations of
// member classes. Such a representation is not needed for compilation, but it
// should be available for clients that want to see all of the declarations in
// the source code.
return TagD;
9353}

9355DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
                                          SourceLocation ExternLoc,
                                          SourceLocation TemplateLoc,
                                          Declarator &D) {
// Explicit instantiations always require a name.
// TODO: check if/when DNInfo should replace Name.
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
if (!Name) {
  if (!D.isInvalidType())
    Diag(D.getDeclSpec().getBeginLoc(),
         diag::err_explicit_instantiation_requires_name)
        << D.getDeclSpec().getSourceRange() << D.getSourceRange();

  return true;
}

// The scope passed in may not be a decl scope.  Zip up the scope tree until
// we find one that is.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
       (S->getFlags() & Scope::TemplateParamScope) != 0)
  S = S->getParent();

// Determine the type of the declaration.
TypeSourceInfo *T = GetTypeForDeclarator(D, S);
QualType R = T->getType();
if (R.isNull())
  return true;

// C++ [dcl.stc]p1:
//   A storage-class-specifier shall not be specified in [...] an explicit
//   instantiation (14.7.2) directive.
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
    << Name;
  return true;
} else if (D.getDeclSpec().getStorageClassSpec()
                                              != DeclSpec::SCS_unspecified) {
  // Complain about then remove the storage class specifier.
  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
    << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());

  D.getMutableDeclSpec().ClearStorageClassSpecs();
}

// C++0x [temp.explicit]p1:
//   [...] An explicit instantiation of a function template shall not use the
//   inline or constexpr specifiers.
// Presumably, this also applies to member functions of class templates as
// well.
if (D.getDeclSpec().isInlineSpecified())
  Diag(D.getDeclSpec().getInlineSpecLoc(),
       getLangOpts().CPlusPlus11 ?
         diag::err_explicit_instantiation_inline :
         diag::warn_explicit_instantiation_inline_0x)
    << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
if (D.getDeclSpec().hasConstexprSpecifier() && R->isFunctionType())
  // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
  // not already specified.
  Diag(D.getDeclSpec().getConstexprSpecLoc(),
       diag::err_explicit_instantiation_constexpr);

// A deduction guide is not on the list of entities that can be explicitly
// instantiated.
if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
  Diag(D.getDeclSpec().getBeginLoc(), diag::err_deduction_guide_specialized)
      << /*explicit instantiation*/ 0;
  return true;
}

// C++0x [temp.explicit]p2:
//   There are two forms of explicit instantiation: an explicit instantiation
//   definition and an explicit instantiation declaration. An explicit
//   instantiation declaration begins with the extern keyword. [...]
TemplateSpecializationKind TSK
  = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                         : TSK_ExplicitInstantiationDeclaration;

LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
LookupParsedName(Previous, S, &D.getCXXScopeSpec());

if (!R->isFunctionType()) {
  // C++ [temp.explicit]p1:
  //   A [...] static data member of a class template can be explicitly
  //   instantiated from the member definition associated with its class
  //   template.
  // C++1y [temp.explicit]p1:
  //   A [...] variable [...] template specialization can be explicitly
  //   instantiated from its template.
  if (Previous.isAmbiguous())
    return true;

  VarDecl *Prev = Previous.getAsSingle<VarDecl>();
  VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();

  if (!PrevTemplate) {
    if (!Prev || !Prev->isStaticDataMember()) {
      // We expect to see a static data member here.
      Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
          << Name;
      for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
           P != PEnd; ++P)
        Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
      return true;
    }

    if (!Prev->getInstantiatedFromStaticDataMember()) {
      // FIXME: Check for explicit specialization?
      Diag(D.getIdentifierLoc(),
           diag::err_explicit_instantiation_data_member_not_instantiated)
          << Prev;
      Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
      // FIXME: Can we provide a note showing where this was declared?
      return true;
    }
  } else {
    // Explicitly instantiate a variable template.

    // C++1y [dcl.spec.auto]p6:
    //   ... A program that uses auto or decltype(auto) in a context not
    //   explicitly allowed in this section is ill-formed.
    //
    // This includes auto-typed variable template instantiations.
    if (R->isUndeducedType()) {
      Diag(T->getTypeLoc().getBeginLoc(),
           diag::err_auto_not_allowed_var_inst);
      return true;
    }

    if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
      // C++1y [temp.explicit]p3:
      //   If the explicit instantiation is for a variable, the unqualified-id
      //   in the declaration shall be a template-id.
      Diag(D.getIdentifierLoc(),
           diag::err_explicit_instantiation_without_template_id)
        << PrevTemplate;
      Diag(PrevTemplate->getLocation(),
           diag::note_explicit_instantiation_here);
      return true;
    }

    // Translate the parser's template argument list into our AST format.
    TemplateArgumentListInfo TemplateArgs =
        makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);

    DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
                                        D.getIdentifierLoc(), TemplateArgs);
    if (Res.isInvalid())
      return true;

    // Ignore access control bits, we don't need them for redeclaration
    // checking.
    Prev = cast<VarDecl>(Res.get());
  }

  // C++0x [temp.explicit]p2:
  //   If the explicit instantiation is for a member function, a member class
  //   or a static data member of a class template specialization, the name of
  //   the class template specialization in the qualified-id for the member
  //   name shall be a simple-template-id.
  //
  // C++98 has the same restriction, just worded differently.
  //
  // This does not apply to variable template specializations, where the
  // template-id is in the unqualified-id instead.
  if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
    Diag(D.getIdentifierLoc(),
         diag::ext_explicit_instantiation_without_qualified_id)
      << Prev << D.getCXXScopeSpec().getRange();

  CheckExplicitInstantiation(*this, Prev, D.getIdentifierLoc(), true, TSK);

  // Verify that it is okay to explicitly instantiate here.
  TemplateSpecializationKind PrevTSK = Prev->getTemplateSpecializationKind();
  SourceLocation POI = Prev->getPointOfInstantiation();
  bool HasNoEffect = false;
  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
                                             PrevTSK, POI, HasNoEffect))
    return true;

  if (!HasNoEffect) {
    // Instantiate static data member or variable template.
    Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
    // Merge attributes.
    ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes());
    if (TSK == TSK_ExplicitInstantiationDefinition)
      InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
  }

  // Check the new variable specialization against the parsed input.
  if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
    Diag(T->getTypeLoc().getBeginLoc(),
         diag::err_invalid_var_template_spec_type)
        << 0 << PrevTemplate << R << Prev->getType();
    Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
        << 2 << PrevTemplate->getDeclName();
    return true;
  }

  // FIXME: Create an ExplicitInstantiation node?
  return (Decl*) nullptr;
}

// If the declarator is a template-id, translate the parser's template
// argument list into our AST format.
bool HasExplicitTemplateArgs = false;
TemplateArgumentListInfo TemplateArgs;
if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
  TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
  HasExplicitTemplateArgs = true;
}

// C++ [temp.explicit]p1:
//   A [...] function [...] can be explicitly instantiated from its template.
//   A member function [...] of a class template can be explicitly
//  instantiated from the member definition associated with its class
//  template.
UnresolvedSet<8> TemplateMatches;
FunctionDecl *NonTemplateMatch = nullptr;
TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
     P != PEnd; ++P) {
  NamedDecl *Prev = *P;
  if (!HasExplicitTemplateArgs) {
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
      QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
                                              /*AdjustExceptionSpec*/true);
      if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
        if (Method->getPrimaryTemplate()) {
          TemplateMatches.addDecl(Method, P.getAccess());
        } else {
          // FIXME: Can this assert ever happen?  Needs a test.
          assert(!NonTemplateMatch && "Multiple NonTemplateMatches")((!NonTemplateMatch && "Multiple NonTemplateMatches")
 ? static_cast<void> (0) : __assert_fail ("!NonTemplateMatch && \"Multiple NonTemplateMatches\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9587, __PRETTY_FUNCTION__));
          NonTemplateMatch = Method;
        }
      }
    }
  }

  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
  if (!FunTmpl)
    continue;

  TemplateDeductionInfo Info(FailedCandidates.getLocation());
  FunctionDecl *Specialization = nullptr;
  if (TemplateDeductionResult TDK
        = DeduceTemplateArguments(FunTmpl,
                             (HasExplicitTemplateArgs ? &TemplateArgs
                                                      : nullptr),
                                  R, Specialization, Info)) {
    // Keep track of almost-matches.
    FailedCandidates.addCandidate()
        .set(P.getPair(), FunTmpl->getTemplatedDecl(),
             MakeDeductionFailureInfo(Context, TDK, Info));
    (void)TDK;
    continue;
  }

  // Target attributes are part of the cuda function signature, so
  // the cuda target of the instantiated function must match that of its
  // template.  Given that C++ template deduction does not take
  // target attributes into account, we reject candidates here that
  // have a different target.
  if (LangOpts.CUDA &&
      IdentifyCUDATarget(Specialization,
                         /* IgnoreImplicitHDAttr = */ true) !=
          IdentifyCUDATarget(D.getDeclSpec().getAttributes())) {
    FailedCandidates.addCandidate().set(
        P.getPair(), FunTmpl->getTemplatedDecl(),
        MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
    continue;
  }

  TemplateMatches.addDecl(Specialization, P.getAccess());
}

FunctionDecl *Specialization = NonTemplateMatch;
if (!Specialization) {
  // Find the most specialized function template specialization.
  UnresolvedSetIterator Result = getMostSpecialized(
      TemplateMatches.begin(), TemplateMatches.end(), FailedCandidates,
      D.getIdentifierLoc(),
      PDiag(diag::err_explicit_instantiation_not_known) << Name,
      PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
      PDiag(diag::note_explicit_instantiation_candidate));

  if (Result == TemplateMatches.end())
    return true;

  // Ignore access control bits, we don't need them for redeclaration checking.
  Specialization = cast<FunctionDecl>(*Result);
}

// C++11 [except.spec]p4
// In an explicit instantiation an exception-specification may be specified,
// but is not required.
// If an exception-specification is specified in an explicit instantiation
// directive, it shall be compatible with the exception-specifications of
// other declarations of that function.
if (auto *FPT = R->getAs<FunctionProtoType>())
  if (FPT->hasExceptionSpec()) {
    unsigned DiagID =
        diag::err_mismatched_exception_spec_explicit_instantiation;
    if (getLangOpts().MicrosoftExt)
      DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
    bool Result = CheckEquivalentExceptionSpec(
        PDiag(DiagID) << Specialization->getType(),
        PDiag(diag::note_explicit_instantiation_here),
        Specialization->getType()->getAs<FunctionProtoType>(),
        Specialization->getLocation(), FPT, D.getBeginLoc());
    // In Microsoft mode, mismatching exception specifications just cause a
    // warning.
    if (!getLangOpts().MicrosoftExt && Result)
      return true;
  }

if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
  Diag(D.getIdentifierLoc(),
       diag::err_explicit_instantiation_member_function_not_instantiated)
    << Specialization
    << (Specialization->getTemplateSpecializationKind() ==
        TSK_ExplicitSpecialization);
  Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
  return true;
}

FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
if (!PrevDecl && Specialization->isThisDeclarationADefinition())
  PrevDecl = Specialization;

if (PrevDecl) {
  bool HasNoEffect = false;
  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
                                             PrevDecl,
                                   PrevDecl->getTemplateSpecializationKind(),
                                        PrevDecl->getPointOfInstantiation(),
                                             HasNoEffect))
    return true;

  // FIXME: We may still want to build some representation of this
  // explicit specialization.
  if (HasNoEffect)
    return (Decl*) nullptr;
}

// HACK: libc++ has a bug where it attempts to explicitly instantiate the
// functions
//     valarray<size_t>::valarray(size_t) and
//     valarray<size_t>::~valarray()
// that it declared to have internal linkage with the internal_linkage
// attribute. Ignore the explicit instantiation declaration in this case.
if (Specialization->hasAttr<InternalLinkageAttr>() &&
    TSK == TSK_ExplicitInstantiationDeclaration) {
  if (auto *RD = dyn_cast<CXXRecordDecl>(Specialization->getDeclContext()))
    if (RD->getIdentifier() && RD->getIdentifier()->isStr("valarray") &&
        RD->isInStdNamespace())
      return (Decl*) nullptr;
}

ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes());

// In MSVC mode, dllimported explicit instantiation definitions are treated as
// instantiation declarations.
if (TSK == TSK_ExplicitInstantiationDefinition &&
    Specialization->hasAttr<DLLImportAttr>() &&
    Context.getTargetInfo().getCXXABI().isMicrosoft())
  TSK = TSK_ExplicitInstantiationDeclaration;

Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());

if (Specialization->isDefined()) {
  // Let the ASTConsumer know that this function has been explicitly
  // instantiated now, and its linkage might have changed.
  Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
} else if (TSK == TSK_ExplicitInstantiationDefinition)
  InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);

// C++0x [temp.explicit]p2:
//   If the explicit instantiation is for a member function, a member class
//   or a static data member of a class template specialization, the name of
//   the class template specialization in the qualified-id for the member
//   name shall be a simple-template-id.
//
// C++98 has the same restriction, just worded differently.
FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
    D.getCXXScopeSpec().isSet() &&
    !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
  Diag(D.getIdentifierLoc(),
       diag::ext_explicit_instantiation_without_qualified_id)
  << Specialization << D.getCXXScopeSpec().getRange();

CheckExplicitInstantiation(
    *this,
    FunTmpl ? (NamedDecl *)FunTmpl
            : Specialization->getInstantiatedFromMemberFunction(),
    D.getIdentifierLoc(), D.getCXXScopeSpec().isSet(), TSK);

// FIXME: Create some kind of ExplicitInstantiationDecl here.
return (Decl*) nullptr;
9755}

9757TypeResult
9758Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                      const CXXScopeSpec &SS, IdentifierInfo *Name,
                      SourceLocation TagLoc, SourceLocation NameLoc) {
// This has to hold, because SS is expected to be defined.
assert(Name && "Expected a name in a dependent tag")((Name && "Expected a name in a dependent tag") ? static_cast
<void> (0) : __assert_fail ("Name && \"Expected a name in a dependent tag\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9762, __PRETTY_FUNCTION__));

NestedNameSpecifier *NNS = SS.getScopeRep();
if (!NNS)
  return true;

TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);

if (TUK == TUK_Declaration || TUK == TUK_Definition) {
  Diag(NameLoc, diag::err_dependent_tag_decl)
    << (TUK == TUK_Definition) << Kind << SS.getRange();
  return true;
}

// Create the resulting type.
ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
QualType Result = Context.getDependentNameType(Kwd, NNS, Name);

// Create type-source location information for this type.
TypeLocBuilder TLB;
DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
TL.setElaboratedKeywordLoc(TagLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));
TL.setNameLoc(NameLoc);
return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
9787}

9789TypeResult
9790Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
                      const CXXScopeSpec &SS, const IdentifierInfo &II,
                      SourceLocation IdLoc) {
if (SS.isInvalid())
  return true;

if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TypenameLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_typename_outside_of_template :
         diag::ext_typename_outside_of_template)
    << FixItHint::CreateRemoval(TypenameLoc);

NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
                               TypenameLoc, QualifierLoc, II, IdLoc);
if (T.isNull())
  return true;

TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
if (isa<DependentNameType>(T)) {
  DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
  TL.setElaboratedKeywordLoc(TypenameLoc);
  TL.setQualifierLoc(QualifierLoc);
  TL.setNameLoc(IdLoc);
} else {
  ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
  TL.setElaboratedKeywordLoc(TypenameLoc);
  TL.setQualifierLoc(QualifierLoc);
  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
}

return CreateParsedType(T, TSI);
9823}

9825TypeResult
9826Sema::ActOnTypenameType(Scope *S,
                      SourceLocation TypenameLoc,
                      const CXXScopeSpec &SS,
                      SourceLocation TemplateKWLoc,
                      TemplateTy TemplateIn,
                      IdentifierInfo *TemplateII,
                      SourceLocation TemplateIILoc,
                      SourceLocation LAngleLoc,
                      ASTTemplateArgsPtr TemplateArgsIn,
                      SourceLocation RAngleLoc) {
if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
  Diag(TypenameLoc,
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_typename_outside_of_template :
         diag::ext_typename_outside_of_template)
    << FixItHint::CreateRemoval(TypenameLoc);

// Strangely, non-type results are not ignored by this lookup, so the
// program is ill-formed if it finds an injected-class-name.
if (TypenameLoc.isValid()) {
  auto *LookupRD =
      dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
    Diag(TemplateIILoc,
         diag::ext_out_of_line_qualified_id_type_names_constructor)
      << TemplateII << 0 /*injected-class-name used as template name*/
      << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
  }
}

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

TemplateName Template = TemplateIn.get();
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  // Construct a dependent template specialization type.
  assert(DTN && "dependent template has non-dependent name?")((DTN && "dependent template has non-dependent name?"
) ? static_cast<void> (0) : __assert_fail ("DTN && \"dependent template has non-dependent name?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9863, __PRETTY_FUNCTION__));
  assert(DTN->getQualifier() == SS.getScopeRep())((DTN->getQualifier() == SS.getScopeRep()) ? static_cast<
void> (0) : __assert_fail ("DTN->getQualifier() == SS.getScopeRep()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9864, __PRETTY_FUNCTION__));
  QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
                                                        DTN->getQualifier(),
                                                        DTN->getIdentifier(),
                                                              TemplateArgs);

  // Create source-location information for this type.
  TypeLocBuilder Builder;
  DependentTemplateSpecializationTypeLoc SpecTL
  = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
  SpecTL.setElaboratedKeywordLoc(TypenameLoc);
  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
  SpecTL.setTemplateNameLoc(TemplateIILoc);
  SpecTL.setLAngleLoc(LAngleLoc);
  SpecTL.setRAngleLoc(RAngleLoc);
  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
    SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
}

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

// Provide source-location information for the template specialization type.
TypeLocBuilder Builder;
TemplateSpecializationTypeLoc SpecTL
  = Builder.push<TemplateSpecializationTypeLoc>(T);
SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
SpecTL.setTemplateNameLoc(TemplateIILoc);
SpecTL.setLAngleLoc(LAngleLoc);
SpecTL.setRAngleLoc(RAngleLoc);
for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());

T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
TL.setElaboratedKeywordLoc(TypenameLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));

TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
return CreateParsedType(T, TSI);
9907}


9910/// Determine whether this failed name lookup should be treated as being
9911/// disabled by a usage of std::enable_if.
9912static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
                     SourceRange &CondRange, Expr *&Cond) {
// We must be looking for a ::type...
if (!II.isStr("type"))
  return false;

// ... within an explicitly-written template specialization...
if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
  return false;
TypeLoc EnableIfTy = NNS.getTypeLoc();
TemplateSpecializationTypeLoc EnableIfTSTLoc =
    EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
  return false;
const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.getTypePtr();

// ... which names a complete class template declaration...
const TemplateDecl *EnableIfDecl =
  EnableIfTST->getTemplateName().getAsTemplateDecl();
if (!EnableIfDecl || EnableIfTST->isIncompleteType())
  return false;

// ... called "enable_if".
const IdentifierInfo *EnableIfII =
  EnableIfDecl->getDeclName().getAsIdentifierInfo();
if (!EnableIfII || !EnableIfII->isStr("enable_if"))
  return false;

// Assume the first template argument is the condition.
CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();

// Dig out the condition.
Cond = nullptr;
if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
      != TemplateArgument::Expression)
  return true;

Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();

// Ignore Boolean literals; they add no value.
if (isa<CXXBoolLiteralExpr>(Cond->IgnoreParenCasts()))
  Cond = nullptr;

return true;
9956}

9958/// Build the type that describes a C++ typename specifier,
9959/// e.g., "typename T::type".
9960QualType
9961Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
                      SourceLocation KeywordLoc,
                      NestedNameSpecifierLoc QualifierLoc,
                      const IdentifierInfo &II,
                      SourceLocation IILoc) {
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

DeclContext *Ctx = computeDeclContext(SS);
if (!Ctx) {
  // If the nested-name-specifier is dependent and couldn't be
  // resolved to a type, build a typename type.
  assert(QualifierLoc.getNestedNameSpecifier()->isDependent())((QualifierLoc.getNestedNameSpecifier()->isDependent()) ? static_cast
<void> (0) : __assert_fail ("QualifierLoc.getNestedNameSpecifier()->isDependent()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/SemaTemplate.cpp"
, 9973, __PRETTY_FUNCTION__));
  return Context.getDependentNameType(Keyword,
                                      QualifierLoc.getNestedNameSpecifier(),
                                      &II);
}

// If the nested-name-specifier refers to the current instantiation,
// the "typename" keyword itself is superfluous. In C++03, the
// program is actually ill-formed. However, DR 382 (in C++0x CD1)
// allows such extraneous "typename" keywords, and we retroactively
// apply this DR to C++03 code with only a warning. In any case we continue.

if (RequireCompleteDeclContext(SS, Ctx))
  return QualType();

DeclarationName Name(&II);
LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
LookupQualifiedName(Result, Ctx, SS);
unsigned DiagID = 0;
Decl *Referenced = nullptr;
switch (Result.getResultKind()) {
case LookupResult::NotFound: {
  // If we're looking up 'type' within a template named 'enable_if', produce
  // a more specific diagnostic.
  SourceRange CondRange;
  Expr *Cond = nullptr;
  if (isEnableIf(QualifierLoc, II, CondRange, Cond)) {
    // If we have a condition, narrow it down to the specific failed
    // condition.
    if (Cond) {
      Expr *FailedCond;
      std::string FailedDescription;
      std::tie(FailedCond, FailedDescription) =
        findFailedBooleanCondition(Cond);

      Diag(FailedCond->getExprLoc(),
           diag::err_typename_nested_not_found_requirement)
        << FailedDescription
        << FailedCond->getSourceRange();
      return QualType();
    }

    Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
        << Ctx << CondRange;
    return QualType();
  }

  DiagID = diag::err_typename_nested_not_found;
  break;
}

case LookupResult::FoundUnresolvedValue: {
  // We found a using declaration that is a value. Most likely, the using
  // declaration itself is meant to have the 'typename' keyword.
  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
                        IILoc);
  Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
    << Name << Ctx << FullRange;
  if (UnresolvedUsingValueDecl *Using
        = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
    SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
    Diag(Loc, diag::note_using_value_decl_missing_typename)
      << FixItHint::CreateInsertion(Loc, "typename ");
  }
}
// Fall through to create a dependent typename type, from which we can recover
// better.
LLVM_FALLTHROUGH[[gnu::fallthrough]];

case LookupResult::NotFoundInCurrentInstantiation:
  // Okay, it's a member of an unknown instantiation.
  return Context.getDependentNameType(Keyword,
                                      QualifierLoc.getNestedNameSpecifier(),
                                      &II);

case LookupResult::Found:
  if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
    // C++ [class.qual]p2:
    //   In a lookup in which function names are not ignored and the
    //   nested-name-specifier nominates a class C, if the name specified
    //   after the nested-name-specifier, when looked up in C, is the
    //   injected-class-name of C [...] then the name is instead considered
    //   to name the constructor of class C.
    //
    // Unlike in an elaborated-type-specifier, function names are not ignored
    // in typename-specifier lookup. However, they are ignored in all the
    // contexts where we form a typename type with no keyword (that is, in
    // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
    //
    // FIXME: That's not strictly true: mem-initializer-id lookup does not
    // ignore functions, but that appears to be an oversight.
    auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
    auto *FoundRD = dyn_cast<CXXRecordDecl>(Type);
    if (Keyword == ETK_Typename && LookupRD && FoundRD &&
        FoundRD->isInjectedClassName() &&
        declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
      Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
          << &II << 1 << 0 /*'typename' keyword used*/;

    // We found a type. Build an ElaboratedType, since the
    // typename-specifier was just sugar.
    MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
    return Context.getElaboratedType(Keyword,
                                     QualifierLoc.getNestedNameSpecifier(),
                                     Context.getTypeDeclType(Type));
  }

  // C++ [dcl.type.simple]p2:
  //   A type-specifier of the form
  //     typename[opt] nested-name-specifier[opt] template-name
  //   is a placeholder for a deduced class type [...].
  if (getLangOpts().CPlusPlus17) {
    if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {
      return Context.getElaboratedType(
          Keyword, QualifierLoc.getNestedNameSpecifier(),
          Context.getDeducedTemplateSpecializationType(TemplateName(TD),
                                                       QualType(), false));
    }
  }

  DiagID = diag::err_typename_nested_not_type;
  Referenced = Result.getFoundDecl();
  break;

case LookupResult::FoundOverloaded:
  DiagID = diag::err_typename_nested_not_type;
  Referenced = *Result.begin();
  break;

case LookupResult::Ambiguous:
  return QualType();
}

// If we get here, it's because name lookup did not find a
// type. Emit an appropriate diagnostic and return an error.
SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
                      IILoc);
Diag(IILoc, DiagID) << FullRange << Name << Ctx;
if (Referenced)
  Diag(Referenced->getLocation(), diag::note_typename_refers_here)
    << Name;
return QualType();
10115}

10117namespace {
// See Sema::RebuildTypeInCurrentInstantiation
class CurrentInstantiationRebuilder
  : public TreeTransform<CurrentInstantiationRebuilder> {
  SourceLocation Loc;
  DeclarationName Entity;

public:
  typedef TreeTransform<CurrentInstantiationRebuilder> inherited;

  CurrentInstantiationRebuilder(Sema &SemaRef,
                                SourceLocation Loc,
                                DeclarationName Entity)
  : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
    Loc(Loc), Entity(Entity) { }

  /// Determine whether the given type \p T has already been
  /// transformed.
  ///
  /// For the purposes of type reconstruction, a type has already been
  /// transformed if it is NULL or if it is not dependent.
  bool AlreadyTransformed(QualType T) {
    return T.isNull() || !T->isDependentType();
  }

  /// Returns the location of the entity whose type is being
  /// rebuilt.
  SourceLocation getBaseLocation() { return Loc; }

  /// Returns the name of the entity whose type is being rebuilt.
  DeclarationName getBaseEntity() { return Entity; }

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

  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    // Lambdas never need to be transformed.
    return E;
  }
};
10161} // end anonymous namespace

10163/// Rebuilds a type within the context of the current instantiation.
10164///
10165/// The type \p T is part of the type of an out-of-line member definition of
10166/// a class template (or class template partial specialization) that was parsed
10167/// and constructed before we entered the scope of the class template (or
10168/// partial specialization thereof). This routine will rebuild that type now
10169/// that we have entered the declarator's scope, which may produce different
10170/// canonical types, e.g.,
10171///
10172/// \code
10173/// template<typename T>
10174/// struct X {
10175///   typedef T* pointer;
10176///   pointer data();
10177/// };
10178///
10179/// template<typename T>
10180/// typename X<T>::pointer X<T>::data() { ... }
10181/// \endcode
10182///
10183/// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
10184/// since we do not know that we can look into X<T> when we parsed the type.
10185/// This function will rebuild the type, performing the lookup of "pointer"
10186/// in X<T> and returning an ElaboratedType whose canonical type is the same
10187/// as the canonical type of T*, allowing the return types of the out-of-line
10188/// definition and the declaration to match.
10189TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
                                                      SourceLocation Loc,
                                                      DeclarationName Name) {
if (!T || !T->getType()->isDependentType())
  return T;

CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
return Rebuilder.TransformType(T);
10197}

10199ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) {
CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
                                        DeclarationName());
return Rebuilder.TransformExpr(E);
10203}

10205bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) {
if (SS.isInvalid())
  return true;

NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
                                        DeclarationName());
NestedNameSpecifierLoc Rebuilt
  = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
if (!Rebuilt)
  return true;

SS.Adopt(Rebuilt);
return false;
10219}

10221/// Rebuild the template parameters now that we know we're in a current
10222/// instantiation.
10223bool Sema::RebuildTemplateParamsInCurrentInstantiation(
                                             TemplateParameterList *Params) {
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  Decl *Param = Params->getParam(I);

  // There is nothing to rebuild in a type parameter.
  if (isa<TemplateTypeParmDecl>(Param))
    continue;

  // Rebuild the template parameter list of a template template parameter.
  if (TemplateTemplateParmDecl *TTP
      = dyn_cast<TemplateTemplateParmDecl>(Param)) {
    if (RebuildTemplateParamsInCurrentInstantiation(
          TTP->getTemplateParameters()))
      return true;

    continue;
  }

  // Rebuild the type of a non-type template parameter.
  NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
  TypeSourceInfo *NewTSI
    = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
                                        NTTP->getLocation(),
                                        NTTP->getDeclName());
  if (!NewTSI)
    return true;

  if (NewTSI->getType()->isUndeducedType()) {
    // C++17 [temp.dep.expr]p3:
    //   An id-expression is type-dependent if it contains
    //    - an identifier associated by name lookup with a non-type
    //      template-parameter declared with a type that contains a
    //      placeholder type (7.1.7.4),
    NewTSI = SubstAutoTypeSourceInfo(NewTSI, Context.DependentTy);
  }

  if (NewTSI != NTTP->getTypeSourceInfo()) {
    NTTP->setTypeSourceInfo(NewTSI);
    NTTP->setType(NewTSI->getType());
  }
}

return false;
10267}

10269/// Produces a formatted string that describes the binding of
10270/// template parameters to template arguments.
10271std::string
10272Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                    const TemplateArgumentList &Args) {
return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
10275}

10277std::string
10278Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                    const TemplateArgument *Args,
                                    unsigned NumArgs) {
SmallString<128> Str;
llvm::raw_svector_ostream Out(Str);

if (!Params || Params->size() == 0 || NumArgs == 0)
  return std::string();

for (unsigned I = 0, N = Params->size(); I != N; ++I) {
  if (I >= NumArgs)
    break;

  if (I == 0)
    Out << "[with ";
  else
    Out << ", ";

  if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
    Out << Id->getName();
  } else {
    Out << '$' << I;
  }

  Out << " = ";
  Args[I].print(getPrintingPolicy(), Out);
}

Out << ']';
return Out.str();
10308}

10310void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
                                  CachedTokens &Toks) {
if (!FD)
  return;

auto LPT = std::make_unique<LateParsedTemplate>();

// Take tokens to avoid allocations
LPT->Toks.swap(Toks);
LPT->D = FnD;
LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));

FD->setLateTemplateParsed(true);
10323}

10325void Sema::UnmarkAsLateParsedTemplate(FunctionDecl *FD) {
if (!FD)
  return;
FD->setLateTemplateParsed(false);
10329}

10331bool Sema::IsInsideALocalClassWithinATemplateFunction() {
DeclContext *DC = CurContext;

while (DC) {
  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
    const FunctionDecl *FD = RD->isLocalClass();
    return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
  } else if (DC->isTranslationUnit() || DC->isNamespace())
    return false;

  DC = DC->getParent();
}
return false;
10344}

10346namespace {
10347/// Walk the path from which a declaration was instantiated, and check
10348/// that every explicit specialization along that path is visible. This enforces
10349/// C++ [temp.expl.spec]/6:
10350///
10351///   If a template, a member template or a member of a class template is
10352///   explicitly specialized then that specialization shall be declared before
10353///   the first use of that specialization that would cause an implicit
10354///   instantiation to take place, in every translation unit in which such a
10355///   use occurs; no diagnostic is required.
10356///
10357/// and also C++ [temp.class.spec]/1:
10358///
10359///   A partial specialization shall be declared before the first use of a
10360///   class template specialization that would make use of the partial
10361///   specialization as the result of an implicit or explicit instantiation
10362///   in every translation unit in which such a use occurs; no diagnostic is
10363///   required.
10364class ExplicitSpecializationVisibilityChecker {
Sema &S;
SourceLocation Loc;
llvm::SmallVector<Module *, 8> Modules;

10369public:
ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
    : S(S), Loc(Loc) {}

void check(NamedDecl *ND) {
  if (auto *FD = dyn_cast<FunctionDecl>(ND))
    return checkImpl(FD);
  if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
    return checkImpl(RD);
  if (auto *VD = dyn_cast<VarDecl>(ND))
    return checkImpl(VD);
  if (auto *ED = dyn_cast<EnumDecl>(ND))
    return checkImpl(ED);
}

10384private:
void diagnose(NamedDecl *D, bool IsPartialSpec) {
  auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
                            : Sema::MissingImportKind::ExplicitSpecialization;
  const bool Recover = true;

  // If we got a custom set of modules (because only a subset of the
  // declarations are interesting), use them, otherwise let
  // diagnoseMissingImport intelligently pick some.
  if (Modules.empty())
    S.diagnoseMissingImport(Loc, D, Kind, Recover);
  else
    S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
}

// Check a specific declaration. There are three problematic cases:
//
//  1) The declaration is an explicit specialization of a template
//     specialization.
//  2) The declaration is an explicit specialization of a member of an
//     templated class.
//  3) The declaration is an instantiation of a template, and that template
//     is an explicit specialization of a member of a templated class.
//
// We don't need to go any deeper than that, as the instantiation of the
// surrounding class / etc is not triggered by whatever triggered this
// instantiation, and thus should be checked elsewhere.
template<typename SpecDecl>
void checkImpl(SpecDecl *Spec) {
  bool IsHiddenExplicitSpecialization = false;
  if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
    IsHiddenExplicitSpecialization =
        Spec->getMemberSpecializationInfo()
            ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
            : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
  } else {
    checkInstantiated(Spec);
  }

  if (IsHiddenExplicitSpecialization)
    diagnose(Spec->getMostRecentDecl(), false);
}

void checkInstantiated(FunctionDecl *FD) {
  if (auto *TD = FD->getPrimaryTemplate())
    checkTemplate(TD);
}

void checkInstantiated(CXXRecordDecl *RD) {
  auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
  if (!SD)
    return;

  auto From = SD->getSpecializedTemplateOrPartial();
  if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
    checkTemplate(TD);
  else if (auto *TD =
               From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
    if (!S.hasVisibleDeclaration(TD))
      diagnose(TD, true);
    checkTemplate(TD);
  }
}

void checkInstantiated(VarDecl *RD) {
  auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
  if (!SD)
    return;

  auto From = SD->getSpecializedTemplateOrPartial();
  if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
    checkTemplate(TD);
  else if (auto *TD =
               From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
    if (!S.hasVisibleDeclaration(TD))
      diagnose(TD, true);
    checkTemplate(TD);
  }
}

void checkInstantiated(EnumDecl *FD) {}

template<typename TemplDecl>
void checkTemplate(TemplDecl *TD) {
  if (TD->isMemberSpecialization()) {
    if (!S.hasVisibleMemberSpecialization(TD, &Modules))
      diagnose(TD->getMostRecentDecl(), false);
  }
}
10473};
10474} // end anonymous namespace

10476void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
if (!getLangOpts().Modules)
  return;

ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
10481}

10483/// Check whether a template partial specialization that we've discovered
10484/// is hidden, and produce suitable diagnostics if so.
10485void Sema::checkPartialSpecializationVisibility(SourceLocation Loc,
                                              NamedDecl *Spec) {
llvm::SmallVector<Module *, 8> Modules;
if (!hasVisibleDeclaration(Spec, &Modules))
  diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
                        MissingImportKind::PartialSpecialization,
                        /*Recover*/true);
10492}

←

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h

→

1//===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===//
7//
8//  This file implements a semantic tree transformation that takes a given
9//  AST and rebuilds it, possibly transforming some nodes in the process.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H

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

40namespace clang {
41using namespace sema;

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

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

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

113protected:
Sema &SemaRef;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

364/// Transform the specified attribute.
365///
366/// Subclasses should override the transformation of attributes with a pragma
367/// spelling to transform expressions stored within the attribute.
368///
369/// \returns the transformed attribute.
370#define ATTR(X)
371#define PRAGMA_SPELLING_ATTR(X)                                                \
const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
373#include "clang/Basic/AttrList.inc"

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

/// Transform the given initializer.
///
/// By default, this routine transforms an initializer by stripping off the
/// semantic nodes added by initialization, then passing the result to
/// TransformExpr or TransformExprs.
///
/// \returns the transformed initializer.
ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);

/// Transform the given list of expressions.
///
/// This routine transforms a list of expressions by invoking
/// \c TransformExpr() for each subexpression. However, it also provides
/// support for variadic templates by expanding any pack expansions (if the
/// derived class permits such expansion) along the way. When pack expansions
/// are present, the number of outputs may not equal the number of inputs.
///
/// \param Inputs The set of expressions to be transformed.
///
/// \param NumInputs The number of expressions in \c Inputs.
///
/// \param IsCall If \c true, then this transform is being performed on
/// function-call arguments, and any arguments that should be dropped, will
/// be.
///
/// \param Outputs The transformed input expressions will be added to this
/// vector.
///
/// \param ArgChanged If non-NULL, will be set \c true if any argument changed
/// due to transformation.
///
/// \returns true if an error occurred, false otherwise.
bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
                    SmallVectorImpl<Expr *> &Outputs,
                    bool *ArgChanged = nullptr);

/// Transform the given declaration, which is referenced from a type
/// or expression.
///
/// By default, acts as the identity function on declarations, unless the
/// transformer has had to transform the declaration itself. Subclasses
/// may override this function to provide alternate behavior.
Decl *TransformDecl(SourceLocation Loc, Decl *D) {
  llvm::DenseMap<Decl *, Decl *>::iterator Known
    = TransformedLocalDecls.find(D);
  if (Known != TransformedLocalDecls.end())
    return Known->second;

  return D;
}

/// Transform the specified condition.
///
/// By default, this transforms the variable and expression and rebuilds
/// the condition.
Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
                                         Expr *Expr,
                                         Sema::ConditionKind Kind);

/// Transform the attributes associated with the given declaration and
/// place them on the new declaration.
///
/// By default, this operation does nothing. Subclasses may override this
/// behavior to transform attributes.
void transformAttrs(Decl *Old, Decl *New) { }

/// Note that a local declaration has been transformed by this
/// transformer.
///
/// Local declarations are typically transformed via a call to
/// TransformDefinition. However, in some cases (e.g., lambda expressions),
/// the transformer itself has to transform the declarations. This routine
/// can be overridden by a subclass that keeps track of such mappings.
void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> New) {
  assert(New.size() == 1 &&((New.size() == 1 && "must override transformedLocalDecl if performing pack expansion"
) ? static_cast<void> (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 460, __PRETTY_FUNCTION__))
         "must override transformedLocalDecl if performing pack expansion")((New.size() == 1 && "must override transformedLocalDecl if performing pack expansion"
) ? static_cast<void> (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 460, __PRETTY_FUNCTION__));
  TransformedLocalDecls[Old] = New.front();
}

/// Transform the definition of the given declaration.
///
/// By default, invokes TransformDecl() to transform the declaration.
/// Subclasses may override this function to provide alternate behavior.
Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
  return getDerived().TransformDecl(Loc, D);
}

/// Transform the given declaration, which was the first part of a
/// nested-name-specifier in a member access expression.
///
/// This specific declaration transformation only applies to the first
/// identifier in a nested-name-specifier of a member access expression, e.g.,
/// the \c T in \c x->T::member
///
/// By default, invokes TransformDecl() to transform the declaration.
/// Subclasses may override this function to provide alternate behavior.
NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
  return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
}

/// Transform the set of declarations in an OverloadExpr.
bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
                                LookupResult &R);

/// Transform the given nested-name-specifier with source-location
/// information.
///
/// By default, transforms all of the types and declarations within the
/// nested-name-specifier. Subclasses may override this function to provide
/// alternate behavior.
NestedNameSpecifierLoc
TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
                                QualType ObjectType = QualType(),
                                NamedDecl *FirstQualifierInScope = nullptr);

/// Transform the given declaration name.
///
/// By default, transforms the types of conversion function, constructor,
/// and destructor names and then (if needed) rebuilds the declaration name.
/// Identifiers and selectors are returned unmodified. Sublcasses may
/// override this function to provide alternate behavior.
DeclarationNameInfo
TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);

/// Transform the given template name.
///
/// \param SS The nested-name-specifier that qualifies the template
/// name. This nested-name-specifier must already have been transformed.
///
/// \param Name The template name to transform.
///
/// \param NameLoc The source location of the template name.
///
/// \param ObjectType If we're translating a template name within a member
/// access expression, this is the type of the object whose member template
/// is being referenced.
///
/// \param FirstQualifierInScope If the first part of a nested-name-specifier
/// also refers to a name within the current (lexical) scope, this is the
/// declaration it refers to.
///
/// By default, transforms the template name by transforming the declarations
/// and nested-name-specifiers that occur within the template name.
/// Subclasses may override this function to provide alternate behavior.
TemplateName
TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
                      SourceLocation NameLoc,
                      QualType ObjectType = QualType(),
                      NamedDecl *FirstQualifierInScope = nullptr,
                      bool AllowInjectedClassName = false);

/// Transform the given template argument.
///
/// By default, this operation transforms the type, expression, or
/// declaration stored within the template argument and constructs a
/// new template argument from the transformed result. Subclasses may
/// override this function to provide alternate behavior.
///
/// Returns true if there was an error.
bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
                               TemplateArgumentLoc &Output,
                               bool Uneval = false);

/// Transform the given set of template arguments.
///
/// By default, this operation transforms all of the template arguments
/// in the input set using \c TransformTemplateArgument(), and appends
/// the transformed arguments to the output list.
///
/// Note that this overload of \c TransformTemplateArguments() is merely
/// a convenience function. Subclasses that wish to override this behavior
/// should override the iterator-based member template version.
///
/// \param Inputs The set of template arguments to be transformed.
///
/// \param NumInputs The number of template arguments in \p Inputs.
///
/// \param Outputs The set of transformed template arguments output by this
/// routine.
///
/// Returns true if an error occurred.
bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
                                unsigned NumInputs,
                                TemplateArgumentListInfo &Outputs,
                                bool Uneval = false) {
  return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
                                    Uneval);
}

/// Transform the given set of template arguments.
///
/// By default, this operation transforms all of the template arguments
/// in the input set using \c TransformTemplateArgument(), and appends
/// the transformed arguments to the output list.
///
/// \param First An iterator to the first template argument.
///
/// \param Last An iterator one step past the last template argument.
///
/// \param Outputs The set of transformed template arguments output by this
/// routine.
///
/// Returns true if an error occurred.
template<typename InputIterator>
bool TransformTemplateArguments(InputIterator First,
                                InputIterator Last,
                                TemplateArgumentListInfo &Outputs,
                                bool Uneval = false);

/// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
void InventTemplateArgumentLoc(const TemplateArgument &Arg,
                               TemplateArgumentLoc &ArgLoc);

/// Fakes up a TypeSourceInfo for a type.
TypeSourceInfo *InventTypeSourceInfo(QualType T) {
  return SemaRef.Context.getTrivialTypeSourceInfo(T,
                     getDerived().getBaseLocation());
}

604#define ABSTRACT_TYPELOC(CLASS, PARENT)
605#define TYPELOC(CLASS, PARENT)                                   \
QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
607#include "clang/AST/TypeLocNodes.def"

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

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

StmtResult TransformSEHHandler(Stmt *Handler);

QualType
TransformTemplateSpecializationType(TypeLocBuilder &TLB,
                                    TemplateSpecializationTypeLoc TL,
                                    TemplateName Template);

QualType
TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                                    DependentTemplateSpecializationTypeLoc TL,
                                             TemplateName Template,
                                             CXXScopeSpec &SS);

QualType TransformDependentTemplateSpecializationType(
    TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
    NestedNameSpecifierLoc QualifierLoc);

/// Transforms the parameters of a function type into the
/// given vectors.
///
/// The result vectors should be kept in sync; null entries in the
/// variables vector are acceptable.
///
/// Return true on error.
bool TransformFunctionTypeParams(
    SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
    const QualType *ParamTypes,
    const FunctionProtoType::ExtParameterInfo *ParamInfos,
    SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
    Sema::ExtParameterInfoBuilder &PInfos);

/// Transforms a single function-type parameter.  Return null
/// on error.
///
/// \param indexAdjustment - A number to add to the parameter's
///   scope index;  can be negative
ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                        int indexAdjustment,
                                        Optional<unsigned> NumExpansions,
                                        bool ExpectParameterPack);

/// Transform the body of a lambda-expression.
StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
/// Alternative implementation of TransformLambdaBody that skips transforming
/// the body.
StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);

QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);

StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);

TemplateParameterList *TransformTemplateParameterList(
      TemplateParameterList *TPL) {
  return TPL;
}

ExprResult TransformAddressOfOperand(Expr *E);

ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
                                              bool IsAddressOfOperand,
                                              TypeSourceInfo **RecoveryTSI);

ExprResult TransformParenDependentScopeDeclRefExpr(
    ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
    TypeSourceInfo **RecoveryTSI);

StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);

690// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
691// amount of stack usage with clang.
692#define STMT(Node, Parent)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
StmtResult Transform##Node(Node *S);
695#define VALUESTMT(Node, Parent)                   \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
698#define EXPR(Node, Parent)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
ExprResult Transform##Node(Node *E);
701#define ABSTRACT_STMT(Stmt)
702#include "clang/AST/StmtNodes.inc"

704#define OPENMP_CLAUSE(Name, Class)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
OMPClause *Transform ## Class(Class *S);
707#include "clang/Basic/OpenMPKinds.def"

/// Build a new qualified type given its unqualified type and type location.
///
/// By default, this routine adds type qualifiers only to types that can
/// have qualifiers, and silently suppresses those qualifiers that are not
/// permitted. Subclasses may override this routine to provide different
/// behavior.
QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);

/// Build a new pointer type given its pointee type.
///
/// By default, performs semantic analysis when building the pointer type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);

/// Build a new block pointer type given its pointee type.
///
/// By default, performs semantic analysis when building the block pointer
/// type. Subclasses may override this routine to provide different behavior.
QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);

/// Build a new reference type given the type it references.
///
/// By default, performs semantic analysis when building the
/// reference type. Subclasses may override this routine to provide
/// different behavior.
///
/// \param LValue whether the type was written with an lvalue sigil
/// or an rvalue sigil.
QualType RebuildReferenceType(QualType ReferentType,
                              bool LValue,
                              SourceLocation Sigil);

/// Build a new member pointer type given the pointee type and the
/// class type it refers into.
///
/// By default, performs semantic analysis when building the member pointer
/// type. Subclasses may override this routine to provide different behavior.
QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
                                  SourceLocation Sigil);

QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                                  SourceLocation ProtocolLAngleLoc,
                                  ArrayRef<ObjCProtocolDecl *> Protocols,
                                  ArrayRef<SourceLocation> ProtocolLocs,
                                  SourceLocation ProtocolRAngleLoc);

/// Build an Objective-C object type.
///
/// By default, performs semantic analysis when building the object type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildObjCObjectType(QualType BaseType,
                               SourceLocation Loc,
                               SourceLocation TypeArgsLAngleLoc,
                               ArrayRef<TypeSourceInfo *> TypeArgs,
                               SourceLocation TypeArgsRAngleLoc,
                               SourceLocation ProtocolLAngleLoc,
                               ArrayRef<ObjCProtocolDecl *> Protocols,
                               ArrayRef<SourceLocation> ProtocolLocs,
                               SourceLocation ProtocolRAngleLoc);

/// Build a new Objective-C object pointer type given the pointee type.
///
/// By default, directly builds the pointer type, with no additional semantic
/// analysis.
QualType RebuildObjCObjectPointerType(QualType PointeeType,
                                      SourceLocation Star);

/// Build a new array type given the element type, size
/// modifier, size of the array (if known), size expression, and index type
/// qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
/// Also by default, all of the other Rebuild*Array
QualType RebuildArrayType(QualType ElementType,
                          ArrayType::ArraySizeModifier SizeMod,
                          const llvm::APInt *Size,
                          Expr *SizeExpr,
                          unsigned IndexTypeQuals,
                          SourceRange BracketsRange);

/// Build a new constant array type given the element type, size
/// modifier, (known) size of the array, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildConstantArrayType(QualType ElementType,
                                  ArrayType::ArraySizeModifier SizeMod,
                                  const llvm::APInt &Size,
                                  unsigned IndexTypeQuals,
                                  SourceRange BracketsRange);

/// Build a new incomplete array type given the element type, size
/// modifier, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildIncompleteArrayType(QualType ElementType,
                                    ArrayType::ArraySizeModifier SizeMod,
                                    unsigned IndexTypeQuals,
                                    SourceRange BracketsRange);

/// Build a new variable-length array type given the element type,
/// size modifier, size expression, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildVariableArrayType(QualType ElementType,
                                  ArrayType::ArraySizeModifier SizeMod,
                                  Expr *SizeExpr,
                                  unsigned IndexTypeQuals,
                                  SourceRange BracketsRange);

/// Build a new dependent-sized array type given the element type,
/// size modifier, size expression, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentSizedArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                        Expr *SizeExpr,
                                        unsigned IndexTypeQuals,
                                        SourceRange BracketsRange);

/// Build a new vector type given the element type and
/// number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
                           VectorType::VectorKind VecKind);

/// Build a new potentially dependently-sized extended vector type
/// given the element type and number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
                                         SourceLocation AttributeLoc,
                                         VectorType::VectorKind);

/// Build a new extended vector type given the element type and
/// number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
                              SourceLocation AttributeLoc);

/// Build a new potentially dependently-sized extended vector type
/// given the element type and number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentSizedExtVectorType(QualType ElementType,
                                            Expr *SizeExpr,
                                            SourceLocation AttributeLoc);

/// Build a new DependentAddressSpaceType or return the pointee
/// type variable with the correct address space (retrieved from
/// AddrSpaceExpr) applied to it. The former will be returned in cases
/// where the address space remains dependent.
///
/// By default, performs semantic analysis when building the type with address
/// space applied. Subclasses may override this routine to provide different
/// behavior.
QualType RebuildDependentAddressSpaceType(QualType PointeeType,
                                          Expr *AddrSpaceExpr,
                                          SourceLocation AttributeLoc);

/// Build a new function type.
///
/// By default, performs semantic analysis when building the function type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildFunctionProtoType(QualType T,
                                  MutableArrayRef<QualType> ParamTypes,
                                  const FunctionProtoType::ExtProtoInfo &EPI);

/// Build a new unprototyped function type.
QualType RebuildFunctionNoProtoType(QualType ResultType);

/// Rebuild an unresolved typename type, given the decl that
/// the UnresolvedUsingTypenameDecl was transformed to.
QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);

/// Build a new typedef type.
QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
  return SemaRef.Context.getTypeDeclType(Typedef);
}

/// Build a new MacroDefined type.
QualType RebuildMacroQualifiedType(QualType T,
                                   const IdentifierInfo *MacroII) {
  return SemaRef.Context.getMacroQualifiedType(T, MacroII);
}

/// Build a new class/struct/union type.
QualType RebuildRecordType(RecordDecl *Record) {
  return SemaRef.Context.getTypeDeclType(Record);
}

/// Build a new Enum type.
QualType RebuildEnumType(EnumDecl *Enum) {
  return SemaRef.Context.getTypeDeclType(Enum);
}

/// Build a new typeof(expr) type.
///
/// By default, performs semantic analysis when building the typeof type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);

/// Build a new typeof(type) type.
///
/// By default, builds a new TypeOfType with the given underlying type.
QualType RebuildTypeOfType(QualType Underlying);

/// Build a new unary transform type.
QualType RebuildUnaryTransformType(QualType BaseType,
                                   UnaryTransformType::UTTKind UKind,
                                   SourceLocation Loc);

/// Build a new C++11 decltype type.
///
/// By default, performs semantic analysis when building the decltype type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);

/// Build a new C++11 auto type.
///
/// By default, builds a new AutoType with the given deduced type.
QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) {
  // Note, IsDependent is always false here: we implicitly convert an 'auto'
  // which has been deduced to a dependent type into an undeduced 'auto', so
  // that we'll retry deduction after the transformation.
  return SemaRef.Context.getAutoType(Deduced, Keyword,
                                     /*IsDependent*/ false);
}

/// By default, builds a new DeducedTemplateSpecializationType with the given
/// deduced type.
QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
    QualType Deduced) {
  return SemaRef.Context.getDeducedTemplateSpecializationType(
      Template, Deduced, /*IsDependent*/ false);
}

/// Build a new template specialization type.
///
/// By default, performs semantic analysis when building the template
/// specialization type. Subclasses may override this routine to provide
/// different behavior.
QualType RebuildTemplateSpecializationType(TemplateName Template,
                                           SourceLocation TemplateLoc,
                                           TemplateArgumentListInfo &Args);

/// Build a new parenthesized type.
///
/// By default, builds a new ParenType type from the inner type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildParenType(QualType InnerType) {
  return SemaRef.BuildParenType(InnerType);
}

/// Build a new qualified name type.
///
/// By default, builds a new ElaboratedType type from the keyword,
/// the nested-name-specifier and the named type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildElaboratedType(SourceLocation KeywordLoc,
                               ElaboratedTypeKeyword Keyword,
                               NestedNameSpecifierLoc QualifierLoc,
                               QualType Named) {
  return SemaRef.Context.getElaboratedType(Keyword,
                                       QualifierLoc.getNestedNameSpecifier(),
                                           Named);
}

/// Build a new typename type that refers to a template-id.
///
/// By default, builds a new DependentNameType type from the
/// nested-name-specifier and the given type. Subclasses may override
/// this routine to provide different behavior.
QualType RebuildDependentTemplateSpecializationType(
                                        ElaboratedTypeKeyword Keyword,
                                        NestedNameSpecifierLoc QualifierLoc,
                                        SourceLocation TemplateKWLoc,
                                        const IdentifierInfo *Name,
                                        SourceLocation NameLoc,
                                        TemplateArgumentListInfo &Args,
                                        bool AllowInjectedClassName) {
  // Rebuild the template name.
  // TODO: avoid TemplateName abstraction
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  TemplateName InstName = getDerived().RebuildTemplateName(
      SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
      AllowInjectedClassName);

  if (InstName.isNull())
    return QualType();

  // If it's still dependent, make a dependent specialization.
  if (InstName.getAsDependentTemplateName())
    return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                                                  Name,
                                                                  Args);

  // Otherwise, make an elaborated type wrapping a non-dependent
  // specialization.
  QualType T =
  getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
  if (T.isNull()) return QualType();

  if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
    return T;

  return SemaRef.Context.getElaboratedType(Keyword,
                                     QualifierLoc.getNestedNameSpecifier(),
                                           T);
}

/// Build a new typename type that refers to an identifier.
///
/// By default, performs semantic analysis when building the typename type
/// (or elaborated type). Subclasses may override this routine to provide
/// different behavior.
QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
                                  SourceLocation KeywordLoc,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  const IdentifierInfo *Id,
                                  SourceLocation IdLoc,
                                  bool DeducedTSTContext) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
    // If the name is still dependent, just build a new dependent name type.
    if (!SemaRef.computeDeclContext(SS))
      return SemaRef.Context.getDependentNameType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                                  Id);
  }

  if (Keyword == ETK_None || Keyword == ETK_Typename) {
    QualType T = SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
                                           *Id, IdLoc);
    // If a dependent name resolves to a deduced template specialization type,
    // check that we're in one of the syntactic contexts permitting it.
    if (!DeducedTSTContext) {
      if (auto *Deduced = dyn_cast_or_null<DeducedTemplateSpecializationType>(
              T.isNull() ? nullptr : T->getContainedDeducedType())) {
        SemaRef.Diag(IdLoc, diag::err_dependent_deduced_tst)
          << (int)SemaRef.getTemplateNameKindForDiagnostics(
                 Deduced->getTemplateName())
          << QualType(QualifierLoc.getNestedNameSpecifier()->getAsType(), 0);
        if (auto *TD = Deduced->getTemplateName().getAsTemplateDecl())
          SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
        return QualType();
      }
    }
    return T;
  }

  TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);

  // We had a dependent elaborated-type-specifier that has been transformed
  // into a non-dependent elaborated-type-specifier. Find the tag we're
  // referring to.
  LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
  DeclContext *DC = SemaRef.computeDeclContext(SS, false);
  if (!DC)
    return QualType();

  if (SemaRef.RequireCompleteDeclContext(SS, DC))
    return QualType();

  TagDecl *Tag = nullptr;
  SemaRef.LookupQualifiedName(Result, DC);
  switch (Result.getResultKind()) {
    case LookupResult::NotFound:
    case LookupResult::NotFoundInCurrentInstantiation:
      break;

    case LookupResult::Found:
      Tag = Result.getAsSingle<TagDecl>();
      break;

    case LookupResult::FoundOverloaded:
    case LookupResult::FoundUnresolvedValue:
      llvm_unreachable("Tag lookup cannot find non-tags")::llvm::llvm_unreachable_internal("Tag lookup cannot find non-tags"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 1100);

    case LookupResult::Ambiguous:
      // Let the LookupResult structure handle ambiguities.
      return QualType();
  }

  if (!Tag) {
    // Check where the name exists but isn't a tag type and use that to emit
    // better diagnostics.
    LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
    SemaRef.LookupQualifiedName(Result, DC);
    switch (Result.getResultKind()) {
      case LookupResult::Found:
      case LookupResult::FoundOverloaded:
      case LookupResult::FoundUnresolvedValue: {
        NamedDecl *SomeDecl = Result.getRepresentativeDecl();
        Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
        SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
                                                             << NTK << Kind;
        SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
        break;
      }
      default:
        SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
            << Kind << Id << DC << QualifierLoc.getSourceRange();
        break;
    }
    return QualType();
  }

  if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
                                            IdLoc, Id)) {
    SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
    SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
    return QualType();
  }

  // Build the elaborated-type-specifier type.
  QualType T = SemaRef.Context.getTypeDeclType(Tag);
  return SemaRef.Context.getElaboratedType(Keyword,
                                       QualifierLoc.getNestedNameSpecifier(),
                                           T);
}

/// Build a new pack expansion type.
///
/// By default, builds a new PackExpansionType type from the given pattern.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildPackExpansionType(QualType Pattern,
                                  SourceRange PatternRange,
                                  SourceLocation EllipsisLoc,
                                  Optional<unsigned> NumExpansions) {
  return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
                                      NumExpansions);
}

/// Build a new atomic type given its value type.
///
/// By default, performs semantic analysis when building the atomic type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);

/// Build a new pipe type given its value type.
QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
                         bool isReadPipe);

/// Build a new template name given a nested name specifier, a flag
/// indicating whether the "template" keyword was provided, and the template
/// that the template name refers to.
///
/// By default, builds the new template name directly. Subclasses may override
/// this routine to provide different behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 bool TemplateKW,
                                 TemplateDecl *Template);

/// Build a new template name given a nested name specifier and the
/// name that is referred to as a template.
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 const IdentifierInfo &Name,
                                 SourceLocation NameLoc, QualType ObjectType,
                                 NamedDecl *FirstQualifierInScope,
                                 bool AllowInjectedClassName);

/// Build a new template name given a nested name specifier and the
/// overloaded operator name that is referred to as a template.
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 OverloadedOperatorKind Operator,
                                 SourceLocation NameLoc, QualType ObjectType,
                                 bool AllowInjectedClassName);

/// Build a new template name given a template template parameter pack
/// and the
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
                                 const TemplateArgument &ArgPack) {
  return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
}

/// Build a new compound statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
                                     MultiStmtArg Statements,
                                     SourceLocation RBraceLoc,
                                     bool IsStmtExpr) {
  return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
                                     IsStmtExpr);
}

/// Build a new case statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
                                 Expr *LHS,
                                 SourceLocation EllipsisLoc,
                                 Expr *RHS,
                                 SourceLocation ColonLoc) {
  return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
                                 ColonLoc);
}

/// Attach the body to a new case statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
  getSema().ActOnCaseStmtBody(S, Body);
  return S;
}

/// Build a new default statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
                                    SourceLocation ColonLoc,
                                    Stmt *SubStmt) {
  return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
                                    /*CurScope=*/nullptr);
}

/// Build a new label statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
                            SourceLocation ColonLoc, Stmt *SubStmt) {
  return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
}

/// Build a new label statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
                                 ArrayRef<const Attr*> Attrs,
                                 Stmt *SubStmt) {
  return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
}

/// Build a new "if" statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
                         Sema::ConditionResult Cond, Stmt *Init, Stmt *Then,
                         SourceLocation ElseLoc, Stmt *Else) {
  return getSema().ActOnIfStmt(IfLoc, IsConstexpr, Init, Cond, Then,
                               ElseLoc, Else);
}

/// Start building a new switch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, Stmt *Init,
                                  Sema::ConditionResult Cond) {
  return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond);
}

/// Attach the body to the switch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
                                 Stmt *Switch, Stmt *Body) {
  return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
}

/// Build a new while statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildWhileStmt(SourceLocation WhileLoc,
                            Sema::ConditionResult Cond, Stmt *Body) {
  return getSema().ActOnWhileStmt(WhileLoc, Cond, Body);
}

/// Build a new do-while statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
                         SourceLocation WhileLoc, SourceLocation LParenLoc,
                         Expr *Cond, SourceLocation RParenLoc) {
  return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
                               Cond, RParenLoc);
}

/// Build a new for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
                          Stmt *Init, Sema::ConditionResult Cond,
                          Sema::FullExprArg Inc, SourceLocation RParenLoc,
                          Stmt *Body) {
  return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
                                Inc, RParenLoc, Body);
}

/// Build a new goto statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
                           LabelDecl *Label) {
  return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
}

/// Build a new indirect goto statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
                                   SourceLocation StarLoc,
                                   Expr *Target) {
  return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
}

/// Build a new return statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
  return getSema().BuildReturnStmt(ReturnLoc, Result);
}

/// Build a new declaration statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
                           SourceLocation StartLoc, SourceLocation EndLoc) {
  Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
  return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
}

/// Build a new inline asm statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                             bool IsVolatile, unsigned NumOutputs,
                             unsigned NumInputs, IdentifierInfo **Names,
                             MultiExprArg Constraints, MultiExprArg Exprs,
                             Expr *AsmString, MultiExprArg Clobbers,
                             unsigned NumLabels,
                             SourceLocation RParenLoc) {
  return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
                                   NumInputs, Names, Constraints, Exprs,
                                   AsmString, Clobbers, NumLabels, RParenLoc);
}

/// Build a new MS style inline asm statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                            ArrayRef<Token> AsmToks,
                            StringRef AsmString,
                            unsigned NumOutputs, unsigned NumInputs,
                            ArrayRef<StringRef> Constraints,
                            ArrayRef<StringRef> Clobbers,
                            ArrayRef<Expr*> Exprs,
                            SourceLocation EndLoc) {
  return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
                                  NumOutputs, NumInputs,
                                  Constraints, Clobbers, Exprs, EndLoc);
}

/// Build a new co_return statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
                               bool IsImplicit) {
  return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
}

/// Build a new co_await expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result,
                              bool IsImplicit) {
  return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit);
}

/// Build a new co_await expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
                                       Expr *Result,
                                       UnresolvedLookupExpr *Lookup) {
  return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
}

/// Build a new co_yield expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
  return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
}

StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
  return getSema().BuildCoroutineBodyStmt(Args);
}

/// Build a new Objective-C \@try statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
                                      Stmt *TryBody,
                                      MultiStmtArg CatchStmts,
                                      Stmt *Finally) {
  return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
                                      Finally);
}

/// Rebuild an Objective-C exception declaration.
///
/// By default, performs semantic analysis to build the new declaration.
/// Subclasses may override this routine to provide different behavior.
VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
                                  TypeSourceInfo *TInfo, QualType T) {
  return getSema().BuildObjCExceptionDecl(TInfo, T,
                                          ExceptionDecl->getInnerLocStart(),
                                          ExceptionDecl->getLocation(),
                                          ExceptionDecl->getIdentifier());
}

/// Build a new Objective-C \@catch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
                                        SourceLocation RParenLoc,
                                        VarDecl *Var,
                                        Stmt *Body) {
  return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
                                        Var, Body);
}

/// Build a new Objective-C \@finally statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
                                          Stmt *Body) {
  return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
}

/// Build a new Objective-C \@throw statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
                                        Expr *Operand) {
  return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
}

/// Build a new OpenMP executable directive.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
                                         DeclarationNameInfo DirName,
                                         OpenMPDirectiveKind CancelRegion,
                                         ArrayRef<OMPClause *> Clauses,
                                         Stmt *AStmt, SourceLocation StartLoc,
                                         SourceLocation EndLoc) {
  return getSema().ActOnOpenMPExecutableDirective(
      Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
}

/// Build a new OpenMP 'if' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
                              Expr *Condition, SourceLocation StartLoc,
                              SourceLocation LParenLoc,
                              SourceLocation NameModifierLoc,
                              SourceLocation ColonLoc,
                              SourceLocation EndLoc) {
  return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
                                       LParenLoc, NameModifierLoc, ColonLoc,
                                       EndLoc);
}

/// Build a new OpenMP 'final' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
                                          EndLoc);
}

/// Build a new OpenMP 'num_threads' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
                                               LParenLoc, EndLoc);
}

/// Build a new OpenMP 'safelen' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'simdlen' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'allocator' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'collapse' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'default' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind,
                                   SourceLocation KindKwLoc,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
                                            StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'proc_bind' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind,
                                    SourceLocation KindKwLoc,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
                                             StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'schedule' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPScheduleClause(
    OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
    OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
    SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPScheduleClause(
      M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
      CommaLoc, EndLoc);
}

/// Build a new OpenMP 'ordered' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
                                   SourceLocation EndLoc,
                                   SourceLocation LParenLoc, Expr *Num) {
  return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
}

/// Build a new OpenMP 'private' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
                                            EndLoc);
}

/// Build a new OpenMP 'firstprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
                                        SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
                                                 EndLoc);
}

/// Build a new OpenMP 'lastprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
                                                EndLoc);
}

/// Build a new OpenMP 'shared' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList,
                                     SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation ColonLoc,
                                     SourceLocation EndLoc,
                                     CXXScopeSpec &ReductionIdScopeSpec,
                                     const DeclarationNameInfo &ReductionId,
                                     ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'task_reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPTaskReductionClause(
    ArrayRef<Expr *> VarList, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
    CXXScopeSpec &ReductionIdScopeSpec,
    const DeclarationNameInfo &ReductionId,
    ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPTaskReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'in_reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
                            SourceLocation LParenLoc, SourceLocation ColonLoc,
                            SourceLocation EndLoc,
                            CXXScopeSpec &ReductionIdScopeSpec,
                            const DeclarationNameInfo &ReductionId,
                            ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPInReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'linear' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  OpenMPLinearClauseKind Modifier,
                                  SourceLocation ModifierLoc,
                                  SourceLocation ColonLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
                                           Modifier, ModifierLoc, ColonLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'aligned' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation ColonLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
                                            LParenLoc, ColonLoc, EndLoc);
}

/// Build a new OpenMP 'copyin' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'copyprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
                                                EndLoc);
}

/// Build a new OpenMP 'flush' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
                                 SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
                                          EndLoc);
}

/// Build a new OpenMP 'depend' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
                       SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
                       SourceLocation StartLoc, SourceLocation LParenLoc,
                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
                                           StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'device' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDeviceClause(Expr *Device, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'map' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPMapClause(
    ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
    ArrayRef<SourceLocation> MapTypeModifiersLoc,
    CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId,
    OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
    SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
    const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPMapClause(MapTypeModifiers, MapTypeModifiersLoc,
                                        MapperIdScopeSpec, MapperId, MapType,
                                        IsMapTypeImplicit, MapLoc, ColonLoc,
                                        VarList, Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'allocate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAllocateClause(Expr *Allocate, ArrayRef<Expr *> VarList,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ColonLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAllocateClause(Allocate, VarList, StartLoc,
                                             LParenLoc, ColonLoc, EndLoc);
}

/// Build a new OpenMP 'num_teams' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'thread_limit' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
                                                LParenLoc, EndLoc);
}

/// Build a new OpenMP 'priority' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'grainsize' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'num_tasks' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'hint' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'dist_schedule' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
                             Expr *ChunkSize, SourceLocation StartLoc,
                             SourceLocation LParenLoc, SourceLocation KindLoc,
                             SourceLocation CommaLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDistScheduleClause(
      Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
}

/// Build a new OpenMP 'to' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPToClause(ArrayRef<Expr *> VarList,
                              CXXScopeSpec &MapperIdScopeSpec,
                              DeclarationNameInfo &MapperId,
                              const OMPVarListLocTy &Locs,
                              ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPToClause(VarList, MapperIdScopeSpec, MapperId,
                                       Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'from' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFromClause(ArrayRef<Expr *> VarList,
                                CXXScopeSpec &MapperIdScopeSpec,
                                DeclarationNameInfo &MapperId,
                                const OMPVarListLocTy &Locs,
                                ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPFromClause(VarList, MapperIdScopeSpec, MapperId,
                                         Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'use_device_ptr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
                                        const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPUseDevicePtrClause(VarList, Locs);
}

/// Build a new OpenMP 'is_device_ptr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
                                       const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
}

/// Rebuild the operand to an Objective-C \@synchronized statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
                                            Expr *object) {
  return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
}

/// Build a new Objective-C \@synchronized statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
                                         Expr *Object, Stmt *Body) {
  return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
}

/// Build a new Objective-C \@autoreleasepool statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
                                          Stmt *Body) {
  return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
}

/// Build a new Objective-C fast enumeration statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
                                        Stmt *Element,
                                        Expr *Collection,
                                        SourceLocation RParenLoc,
                                        Stmt *Body) {
  StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
                                              Element,
                                              Collection,
                                              RParenLoc);
  if (ForEachStmt.isInvalid())
    return StmtError();

  return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
}

/// Build a new C++ exception declaration.
///
/// By default, performs semantic analysis to build the new decaration.
/// Subclasses may override this routine to provide different behavior.
VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
                              TypeSourceInfo *Declarator,
                              SourceLocation StartLoc,
                              SourceLocation IdLoc,
                              IdentifierInfo *Id) {
  VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
                                                     StartLoc, IdLoc, Id);
  if (Var)
    getSema().CurContext->addDecl(Var);
  return Var;
}

/// Build a new C++ catch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
                               VarDecl *ExceptionDecl,
                               Stmt *Handler) {
  return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
                                                    Handler));
}

/// Build a new C++ try statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
                             ArrayRef<Stmt *> Handlers) {
  return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
}

/// Build a new C++0x range-based for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
                                  SourceLocation CoawaitLoc, Stmt *Init,
                                  SourceLocation ColonLoc, Stmt *Range,
                                  Stmt *Begin, Stmt *End, Expr *Cond,
                                  Expr *Inc, Stmt *LoopVar,
                                  SourceLocation RParenLoc) {
  // If we've just learned that the range is actually an Objective-C
  // collection, treat this as an Objective-C fast enumeration loop.
  if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
    if (RangeStmt->isSingleDecl()) {
      if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
        if (RangeVar->isInvalidDecl())
          return StmtError();

        Expr *RangeExpr = RangeVar->getInit();
        if (!RangeExpr->isTypeDependent() &&
            RangeExpr->getType()->isObjCObjectPointerType()) {
          // FIXME: Support init-statements in Objective-C++20 ranged for
          // statement.
          if (Init) {
            return SemaRef.Diag(Init->getBeginLoc(),
                                diag::err_objc_for_range_init_stmt)
                       << Init->getSourceRange();
          }
          return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar,
                                                      RangeExpr, RParenLoc);
        }
      }
    }
  }

  return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, Init, ColonLoc,
                                        Range, Begin, End, Cond, Inc, LoopVar,
                                        RParenLoc, Sema::BFRK_Rebuild);
}

/// Build a new C++0x range-based for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
                                        bool IsIfExists,
                                        NestedNameSpecifierLoc QualifierLoc,
                                        DeclarationNameInfo NameInfo,
                                        Stmt *Nested) {
  return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
                                              QualifierLoc, NameInfo, Nested);
}

/// Attach body to a C++0x range-based for statement.
///
/// By default, performs semantic analysis to finish the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
  return getSema().FinishCXXForRangeStmt(ForRange, Body);
}

StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
                             Stmt *TryBlock, Stmt *Handler) {
  return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
}

StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
                                Stmt *Block) {
  return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
}

StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
  return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
}

/// Build a new predefined expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildPredefinedExpr(SourceLocation Loc,
                                 PredefinedExpr::IdentKind IK) {
  return getSema().BuildPredefinedExpr(Loc, IK);
}

/// Build a new expression that references a declaration.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                      LookupResult &R,
                                      bool RequiresADL) {
  return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
}


/// Build a new expression that references a declaration.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
                              ValueDecl *VD,
                              const DeclarationNameInfo &NameInfo,
                              NamedDecl *Found,
                              TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found,
                                            TemplateArgs);
}

/// Build a new expression in parentheses.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
                                  SourceLocation RParen) {
  return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
}

/// Build a new pseudo-destructor expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
                                          SourceLocation OperatorLoc,
                                          bool isArrow,
                                          CXXScopeSpec &SS,
                                          TypeSourceInfo *ScopeType,
                                          SourceLocation CCLoc,
                                          SourceLocation TildeLoc,
                                      PseudoDestructorTypeStorage Destroyed);

/// Build a new unary operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
                                      UnaryOperatorKind Opc,
                                      Expr *SubExpr) {
  return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
}

/// Build a new builtin offsetof expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
                               TypeSourceInfo *Type,
                               ArrayRef<Sema::OffsetOfComponent> Components,
                               SourceLocation RParenLoc) {
  return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
                                        RParenLoc);
}

/// Build a new sizeof, alignof or vec_step expression with a
/// type argument.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
                                       SourceLocation OpLoc,
                                       UnaryExprOrTypeTrait ExprKind,
                                       SourceRange R) {
  return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
}

/// Build a new sizeof, alignof or vec step expression with an
/// expression argument.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
                                       UnaryExprOrTypeTrait ExprKind,
                                       SourceRange R) {
  ExprResult Result
    = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
  if (Result.isInvalid())
    return ExprError();

  return Result;
}

/// Build a new array subscript expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildArraySubscriptExpr(Expr *LHS,
                                           SourceLocation LBracketLoc,
                                           Expr *RHS,
                                           SourceLocation RBracketLoc) {
  return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
                                           LBracketLoc, RHS,
                                           RBracketLoc);
}

/// Build a new array section expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
                                      Expr *LowerBound,
                                      SourceLocation ColonLoc, Expr *Length,
                                      SourceLocation RBracketLoc) {
  return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
                                            ColonLoc, Length, RBracketLoc);
}

/// Build a new call expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
                                 MultiExprArg Args,
                                 SourceLocation RParenLoc,
                                 Expr *ExecConfig = nullptr) {
  return getSema().BuildCallExpr(/*Scope=*/nullptr, Callee, LParenLoc, Args,
                                 RParenLoc, ExecConfig);
}

/// Build a new member access expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
                             bool isArrow,
                             NestedNameSpecifierLoc QualifierLoc,
                             SourceLocation TemplateKWLoc,
                             const DeclarationNameInfo &MemberNameInfo,
                             ValueDecl *Member,
                             NamedDecl *FoundDecl,
                      const TemplateArgumentListInfo *ExplicitTemplateArgs,
                             NamedDecl *FirstQualifierInScope) {
  ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
                                                                    isArrow);
  if (!Member->getDeclName()) {
    // We have a reference to an unnamed field.  This is always the
    // base of an anonymous struct/union member access, i.e. the
    // field is always of record type.
    assert(Member->getType()->isRecordType() &&((Member->getType()->isRecordType() && "unnamed member not of record type?"
) ? static_cast<void> (0) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 2307, __PRETTY_FUNCTION__))
           "unnamed member not of record type?")((Member->getType()->isRecordType() && "unnamed member not of record type?"
) ? static_cast<void> (0) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 2307, __PRETTY_FUNCTION__));

    BaseResult =
      getSema().PerformObjectMemberConversion(BaseResult.get(),
                                              QualifierLoc.getNestedNameSpecifier(),
                                              FoundDecl, Member);
    if (BaseResult.isInvalid())
      return ExprError();
    Base = BaseResult.get();

    CXXScopeSpec EmptySS;
    return getSema().BuildFieldReferenceExpr(
        Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
        DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
  }

  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  Base = BaseResult.get();
  QualType BaseType = Base->getType();

  if (isArrow && !BaseType->isPointerType())
    return ExprError();

  // FIXME: this involves duplicating earlier analysis in a lot of
  // cases; we should avoid this when possible.
  LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
  R.addDecl(FoundDecl);
  R.resolveKind();

  return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
                                            SS, TemplateKWLoc,
                                            FirstQualifierInScope,
                                            R, ExplicitTemplateArgs,
                                            /*S*/nullptr);
}

/// Build a new binary operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
                                       BinaryOperatorKind Opc,
                                       Expr *LHS, Expr *RHS) {
  return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
}

/// Build a new conditional operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildConditionalOperator(Expr *Cond,
                                      SourceLocation QuestionLoc,
                                      Expr *LHS,
                                      SourceLocation ColonLoc,
                                      Expr *RHS) {
  return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
                                      LHS, RHS);
}

/// Build a new C-style cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
                                       TypeSourceInfo *TInfo,
                                       SourceLocation RParenLoc,
                                       Expr *SubExpr) {
  return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
                                       SubExpr);
}

/// Build a new compound literal expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
                                            TypeSourceInfo *TInfo,
                                            SourceLocation RParenLoc,
                                            Expr *Init) {
  return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
                                            Init);
}

/// Build a new extended vector element access expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildExtVectorElementExpr(Expr *Base,
                                             SourceLocation OpLoc,
                                             SourceLocation AccessorLoc,
                                             IdentifierInfo &Accessor) {

  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
  return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
                                            OpLoc, /*IsArrow*/ false,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope*/ nullptr,
                                            NameInfo,
                                            /* TemplateArgs */ nullptr,
                                            /*S*/ nullptr);
}

/// Build a new initializer list expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildInitList(SourceLocation LBraceLoc,
                           MultiExprArg Inits,
                           SourceLocation RBraceLoc) {
  return SemaRef.BuildInitList(LBraceLoc, Inits, RBraceLoc);
}

/// Build a new designated initializer expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDesignatedInitExpr(Designation &Desig,
                                           MultiExprArg ArrayExprs,
                                           SourceLocation EqualOrColonLoc,
                                           bool GNUSyntax,
                                           Expr *Init) {
  ExprResult Result
    = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
                                         Init);
  if (Result.isInvalid())
    return ExprError();

  return Result;
}

/// Build a new value-initialized expression.
///
/// By default, builds the implicit value initialization without performing
/// any semantic analysis. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildImplicitValueInitExpr(QualType T) {
  return new (SemaRef.Context) ImplicitValueInitExpr(T);
}

/// Build a new \c va_arg expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
                                  Expr *SubExpr, TypeSourceInfo *TInfo,
                                  SourceLocation RParenLoc) {
  return getSema().BuildVAArgExpr(BuiltinLoc,
                                  SubExpr, TInfo,
                                  RParenLoc);
}

/// Build a new expression list in parentheses.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
                                MultiExprArg SubExprs,
                                SourceLocation RParenLoc) {
  return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
}

/// Build a new address-of-label expression.
///
/// By default, performs semantic analysis, using the name of the label
/// rather than attempting to map the label statement itself.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
                                SourceLocation LabelLoc, LabelDecl *Label) {
  return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
}

/// Build a new GNU statement expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
                                 Stmt *SubStmt,
                                 SourceLocation RParenLoc) {
  return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
}

/// Build a new __builtin_choose_expr expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
                                   Expr *Cond, Expr *LHS, Expr *RHS,
                                   SourceLocation RParenLoc) {
  return SemaRef.ActOnChooseExpr(BuiltinLoc,
                                 Cond, LHS, RHS,
                                 RParenLoc);
}

/// Build a new generic selection expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
                                       SourceLocation DefaultLoc,
                                       SourceLocation RParenLoc,
                                       Expr *ControllingExpr,
                                       ArrayRef<TypeSourceInfo *> Types,
                                       ArrayRef<Expr *> Exprs) {
  return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
                                              ControllingExpr, Types, Exprs);
}

/// Build a new overloaded operator call expression.
///
/// By default, performs semantic analysis to build the new expression.
/// The semantic analysis provides the behavior of template instantiation,
/// copying with transformations that turn what looks like an overloaded
/// operator call into a use of a builtin operator, performing
/// argument-dependent lookup, etc. Subclasses may override this routine to
/// provide different behavior.
ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
                                            SourceLocation OpLoc,
                                            Expr *Callee,
                                            Expr *First,
                                            Expr *Second);

/// Build a new C++ "named" cast expression, such as static_cast or
/// reinterpret_cast.
///
/// By default, this routine dispatches to one of the more-specific routines
/// for a particular named case, e.g., RebuildCXXStaticCastExpr().
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
                                         Stmt::StmtClass Class,
                                         SourceLocation LAngleLoc,
                                         TypeSourceInfo *TInfo,
                                         SourceLocation RAngleLoc,
                                         SourceLocation LParenLoc,
                                         Expr *SubExpr,
                                         SourceLocation RParenLoc) {
  switch (Class) {
  case Stmt::CXXStaticCastExprClass:
    return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
                                                 RAngleLoc, LParenLoc,
                                                 SubExpr, RParenLoc);

  case Stmt::CXXDynamicCastExprClass:
    return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
                                                  RAngleLoc, LParenLoc,
                                                  SubExpr, RParenLoc);

  case Stmt::CXXReinterpretCastExprClass:
    return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
                                                      RAngleLoc, LParenLoc,
                                                      SubExpr,
                                                      RParenLoc);

  case Stmt::CXXConstCastExprClass:
    return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
                                                 RAngleLoc, LParenLoc,
                                                 SubExpr, RParenLoc);

  default:
    llvm_unreachable("Invalid C++ named cast")::llvm::llvm_unreachable_internal("Invalid C++ named cast", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 2568);
  }
}

/// Build a new C++ static_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
                                          SourceLocation LAngleLoc,
                                          TypeSourceInfo *TInfo,
                                          SourceLocation RAngleLoc,
                                          SourceLocation LParenLoc,
                                          Expr *SubExpr,
                                          SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ dynamic_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
                                           SourceLocation LAngleLoc,
                                           TypeSourceInfo *TInfo,
                                           SourceLocation RAngleLoc,
                                           SourceLocation LParenLoc,
                                           Expr *SubExpr,
                                           SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ reinterpret_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
                                               SourceLocation LAngleLoc,
                                               TypeSourceInfo *TInfo,
                                               SourceLocation RAngleLoc,
                                               SourceLocation LParenLoc,
                                               Expr *SubExpr,
                                               SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ const_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
                                         SourceLocation LAngleLoc,
                                         TypeSourceInfo *TInfo,
                                         SourceLocation RAngleLoc,
                                         SourceLocation LParenLoc,
                                         Expr *SubExpr,
                                         SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ functional-style cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
                                        SourceLocation LParenLoc,
                                        Expr *Sub,
                                        SourceLocation RParenLoc,
                                        bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
                                             MultiExprArg(&Sub, 1), RParenLoc,
                                             ListInitialization);
}

/// Build a new C++ __builtin_bit_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc,
                                     TypeSourceInfo *TSI, Expr *Sub,
                                     SourceLocation RParenLoc) {
  return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc);
}

/// Build a new C++ typeid(type) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      TypeSourceInfo *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}


/// Build a new C++ typeid(expr) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      Expr *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}

/// Build a new C++ __uuidof(type) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      TypeSourceInfo *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}

/// Build a new C++ __uuidof(expr) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      Expr *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}

/// Build a new C++ "this" expression.
///
/// By default, builds a new "this" expression without performing any
/// semantic analysis. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
                              QualType ThisType,
                              bool isImplicit) {
  return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit);
}

/// Build a new C++ throw expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
                               bool IsThrownVariableInScope) {
  return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
}

/// Build a new C++ default-argument expression.
///
/// By default, builds a new default-argument expression, which does not
/// require any semantic analysis. Subclasses may override this routine to
/// provide different behavior.
ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param) {
  return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
                                   getSema().CurContext);
}

/// Build a new C++11 default-initialization expression.
///
/// By default, builds a new default field initialization expression, which
/// does not require any semantic analysis. Subclasses may override this
/// routine to provide different behavior.
ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
                                     FieldDecl *Field) {
  return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field,
                                    getSema().CurContext);
}

/// Build a new C++ zero-initialization expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
                                         SourceLocation LParenLoc,
                                         SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeConstructExpr(
      TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false);
}

/// Build a new C++ "new" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
                             bool UseGlobal,
                             SourceLocation PlacementLParen,
                             MultiExprArg PlacementArgs,
                             SourceLocation PlacementRParen,
                             SourceRange TypeIdParens,
                             QualType AllocatedType,
                             TypeSourceInfo *AllocatedTypeInfo,
                             Optional<Expr *> ArraySize,
                             SourceRange DirectInitRange,
                             Expr *Initializer) {
  return getSema().BuildCXXNew(StartLoc, UseGlobal,
                               PlacementLParen,
                               PlacementArgs,
                               PlacementRParen,
                               TypeIdParens,
                               AllocatedType,
                               AllocatedTypeInfo,
                               ArraySize,
                               DirectInitRange,
                               Initializer);
}

/// Build a new C++ "delete" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
                                      bool IsGlobalDelete,
                                      bool IsArrayForm,
                                      Expr *Operand) {
  return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
                                  Operand);
}

/// Build a new type trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildTypeTrait(TypeTrait Trait,
                            SourceLocation StartLoc,
                            ArrayRef<TypeSourceInfo *> Args,
                            SourceLocation RParenLoc) {
  return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
}

/// Build a new array type trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
                                 SourceLocation StartLoc,
                                 TypeSourceInfo *TSInfo,
                                 Expr *DimExpr,
                                 SourceLocation RParenLoc) {
  return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
}

/// Build a new expression trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
                                 SourceLocation StartLoc,
                                 Expr *Queried,
                                 SourceLocation RParenLoc) {
  return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
}

/// Build a new (previously unresolved) declaration reference
/// expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDependentScopeDeclRefExpr(
                                        NestedNameSpecifierLoc QualifierLoc,
                                        SourceLocation TemplateKWLoc,
                                     const DeclarationNameInfo &NameInfo,
                            const TemplateArgumentListInfo *TemplateArgs,
                                        bool IsAddressOfOperand,
                                        TypeSourceInfo **RecoveryTSI) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  if (TemplateArgs || TemplateKWLoc.isValid())
    return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
                                                  TemplateArgs);

  return getSema().BuildQualifiedDeclarationNameExpr(
      SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
}

/// Build a new template-id expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 LookupResult &R,
                                 bool RequiresADL,
                            const TemplateArgumentListInfo *TemplateArgs) {
  return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
                                       TemplateArgs);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXConstructExpr(QualType T,
                                   SourceLocation Loc,
                                   CXXConstructorDecl *Constructor,
                                   bool IsElidable,
                                   MultiExprArg Args,
                                   bool HadMultipleCandidates,
                                   bool ListInitialization,
                                   bool StdInitListInitialization,
                                   bool RequiresZeroInit,
                           CXXConstructExpr::ConstructionKind ConstructKind,
                                   SourceRange ParenRange) {
  SmallVector<Expr*, 8> ConvertedArgs;
  if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
                                        ConvertedArgs))
    return ExprError();

  return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
                                         IsElidable,
                                         ConvertedArgs,
                                         HadMultipleCandidates,
                                         ListInitialization,
                                         StdInitListInitialization,
                                         RequiresZeroInit, ConstructKind,
                                         ParenRange);
}

/// Build a new implicit construction via inherited constructor
/// expression.
ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
                                           CXXConstructorDecl *Constructor,
                                           bool ConstructsVBase,
                                           bool InheritedFromVBase) {
  return new (getSema().Context) CXXInheritedCtorInitExpr(
      Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
                                         SourceLocation LParenOrBraceLoc,
                                         MultiExprArg Args,
                                         SourceLocation RParenOrBraceLoc,
                                         bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(
      TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
                                             SourceLocation LParenLoc,
                                             MultiExprArg Args,
                                             SourceLocation RParenLoc,
                                             bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
                                             RParenLoc, ListInitialization);
}

/// Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
                                              QualType BaseType,
                                              bool IsArrow,
                                              SourceLocation OperatorLoc,
                                        NestedNameSpecifierLoc QualifierLoc,
                                              SourceLocation TemplateKWLoc,
                                          NamedDecl *FirstQualifierInScope,
                                 const DeclarationNameInfo &MemberNameInfo,
                            const TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                          OperatorLoc, IsArrow,
                                          SS, TemplateKWLoc,
                                          FirstQualifierInScope,
                                          MemberNameInfo,
                                          TemplateArgs, /*S*/nullptr);
}

/// Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
                                       SourceLocation OperatorLoc,
                                       bool IsArrow,
                                       NestedNameSpecifierLoc QualifierLoc,
                                       SourceLocation TemplateKWLoc,
                                       NamedDecl *FirstQualifierInScope,
                                       LookupResult &R,
                              const TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                          OperatorLoc, IsArrow,
                                          SS, TemplateKWLoc,
                                          FirstQualifierInScope,
                                          R, TemplateArgs, /*S*/nullptr);
}

/// Build a new noexcept expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
  return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
}

/// Build a new expression to compute the length of a parameter pack.
ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc,
                                 NamedDecl *Pack,
                                 SourceLocation PackLoc,
                                 SourceLocation RParenLoc,
                                 Optional<unsigned> Length,
                                 ArrayRef<TemplateArgument> PartialArgs) {
  return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
                                RParenLoc, Length, PartialArgs);
}

/// Build a new expression representing a call to a source location
///  builtin.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                SourceLocation BuiltinLoc,
                                SourceLocation RPLoc,
                                DeclContext *ParentContext) {
  return getSema().BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, ParentContext);
}

/// Build a new Objective-C boxed expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
  return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
}

/// Build a new Objective-C array literal.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCArrayLiteral(SourceRange Range,
                                   Expr **Elements, unsigned NumElements) {
  return getSema().BuildObjCArrayLiteral(Range,
                                         MultiExprArg(Elements, NumElements));
}

ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
                                       Expr *Base, Expr *Key,
                                       ObjCMethodDecl *getterMethod,
                                       ObjCMethodDecl *setterMethod) {
  return  getSema().BuildObjCSubscriptExpression(RB, Base, Key,
                                                 getterMethod, setterMethod);
}

/// Build a new Objective-C dictionary literal.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
                            MutableArrayRef<ObjCDictionaryElement> Elements) {
  return getSema().BuildObjCDictionaryLiteral(Range, Elements);
}

/// Build a new Objective-C \@encode expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
                                       TypeSourceInfo *EncodeTypeInfo,
                                       SourceLocation RParenLoc) {
  return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
}

/// Build a new Objective-C class message.
ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
                                        Selector Sel,
                                        ArrayRef<SourceLocation> SelectorLocs,
                                        ObjCMethodDecl *Method,
                                        SourceLocation LBracLoc,
                                        MultiExprArg Args,
                                        SourceLocation RBracLoc) {
  return SemaRef.BuildClassMessage(ReceiverTypeInfo,
                                   ReceiverTypeInfo->getType(),
                                   /*SuperLoc=*/SourceLocation(),
                                   Sel, Method, LBracLoc, SelectorLocs,
                                   RBracLoc, Args);
}

/// Build a new Objective-C instance message.
ExprResult RebuildObjCMessageExpr(Expr *Receiver,
                                        Selector Sel,
                                        ArrayRef<SourceLocation> SelectorLocs,
                                        ObjCMethodDecl *Method,
                                        SourceLocation LBracLoc,
                                        MultiExprArg Args,
                                        SourceLocation RBracLoc) {
  return SemaRef.BuildInstanceMessage(Receiver,
                                      Receiver->getType(),
                                      /*SuperLoc=*/SourceLocation(),
                                      Sel, Method, LBracLoc, SelectorLocs,
                                      RBracLoc, Args);
}

/// Build a new Objective-C instance/class message to 'super'.
ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
                                  Selector Sel,
                                  ArrayRef<SourceLocation> SelectorLocs,
                                  QualType SuperType,
                                  ObjCMethodDecl *Method,
                                  SourceLocation LBracLoc,
                                  MultiExprArg Args,
                                  SourceLocation RBracLoc) {
  return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr,
                                        SuperType,
                                        SuperLoc,
                                        Sel, Method, LBracLoc, SelectorLocs,
                                        RBracLoc, Args)
                                    : SemaRef.BuildClassMessage(nullptr,
                                        SuperType,
                                        SuperLoc,
                                        Sel, Method, LBracLoc, SelectorLocs,
                                        RBracLoc, Args);


}

/// Build a new Objective-C ivar reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
                                        SourceLocation IvarLoc,
                                        bool IsArrow, bool IsFreeIvar) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
  ExprResult Result = getSema().BuildMemberReferenceExpr(
      BaseArg, BaseArg->getType(),
      /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(),
      /*FirstQualifierInScope=*/nullptr, NameInfo,
      /*TemplateArgs=*/nullptr,
      /*S=*/nullptr);
  if (IsFreeIvar && Result.isUsable())
    cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
  return Result;
}

/// Build a new Objective-C property reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
                                      ObjCPropertyDecl *Property,
                                      SourceLocation PropertyLoc) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
  return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
                                            /*FIXME:*/PropertyLoc,
                                            /*IsArrow=*/false,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope=*/nullptr,
                                            NameInfo,
                                            /*TemplateArgs=*/nullptr,
                                            /*S=*/nullptr);
}

/// Build a new Objective-C property reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
                                      ObjCMethodDecl *Getter,
                                      ObjCMethodDecl *Setter,
                                      SourceLocation PropertyLoc) {
  // Since these expressions can only be value-dependent, we do not
  // need to perform semantic analysis again.
  return Owned(
    new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
                                                VK_LValue, OK_ObjCProperty,
                                                PropertyLoc, Base));
}

/// Build a new Objective-C "isa" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
                              SourceLocation OpLoc, bool IsArrow) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
  return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
                                            OpLoc, IsArrow,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope=*/nullptr,
                                            NameInfo,
                                            /*TemplateArgs=*/nullptr,
                                            /*S=*/nullptr);
}

/// Build a new shuffle vector expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
                                    MultiExprArg SubExprs,
                                    SourceLocation RParenLoc) {
  // Find the declaration for __builtin_shufflevector
  const IdentifierInfo &Name
    = SemaRef.Context.Idents.get("__builtin_shufflevector");
  TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
  DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
  assert(!Lookup.empty() && "No __builtin_shufflevector?")((!Lookup.empty() && "No __builtin_shufflevector?") ?
 static_cast<void> (0) : __assert_fail ("!Lookup.empty() && \"No __builtin_shufflevector?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3199, __PRETTY_FUNCTION__));

  // Build a reference to the __builtin_shufflevector builtin
  FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
  Expr *Callee = new (SemaRef.Context)
      DeclRefExpr(SemaRef.Context, Builtin, false,
                  SemaRef.Context.BuiltinFnTy, VK_RValue, BuiltinLoc);
  QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
  Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
                                     CK_BuiltinFnToFnPtr).get();

  // Build the CallExpr
  ExprResult TheCall = CallExpr::Create(
      SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
      Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc);

  // Type-check the __builtin_shufflevector expression.
  return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
}

/// Build a new convert vector expression.
ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
                                    Expr *SrcExpr, TypeSourceInfo *DstTInfo,
                                    SourceLocation RParenLoc) {
  return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
                                       BuiltinLoc, RParenLoc);
}

/// Build a new template argument pack expansion.
///
/// By default, performs semantic analysis to build a new pack expansion
/// for a template argument. Subclasses may override this routine to provide
/// different behavior.
TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
                                         SourceLocation EllipsisLoc,
                                         Optional<unsigned> NumExpansions) {
  switch (Pattern.getArgument().getKind()) {
  case TemplateArgument::Expression: {
    ExprResult Result
      = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
                                     EllipsisLoc, NumExpansions);
    if (Result.isInvalid())
      return TemplateArgumentLoc();

    return TemplateArgumentLoc(Result.get(), Result.get());
  }

  case TemplateArgument::Template:
    return TemplateArgumentLoc(TemplateArgument(
                                        Pattern.getArgument().getAsTemplate(),
                                                NumExpansions),
                               Pattern.getTemplateQualifierLoc(),
                               Pattern.getTemplateNameLoc(),
                               EllipsisLoc);

  case TemplateArgument::Null:
  case TemplateArgument::Integral:
  case TemplateArgument::Declaration:
  case TemplateArgument::Pack:
  case TemplateArgument::TemplateExpansion:
  case TemplateArgument::NullPtr:
    llvm_unreachable("Pack expansion pattern has no parameter packs")::llvm::llvm_unreachable_internal("Pack expansion pattern has no parameter packs"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3260);

  case TemplateArgument::Type:
    if (TypeSourceInfo *Expansion
          = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
                                         EllipsisLoc,
                                         NumExpansions))
      return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
                                 Expansion);
    break;
  }

  return TemplateArgumentLoc();
}

/// Build a new expression pack expansion.
///
/// By default, performs semantic analysis to build a new pack expansion
/// for an expression. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
                                Optional<unsigned> NumExpansions) {
  return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
}

/// Build a new C++1z fold-expression.
///
/// By default, performs semantic analysis in order to build a new fold
/// expression.
ExprResult RebuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
                              BinaryOperatorKind Operator,
                              SourceLocation EllipsisLoc, Expr *RHS,
                              SourceLocation RParenLoc,
                              Optional<unsigned> NumExpansions) {
  return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc,
                                    RHS, RParenLoc, NumExpansions);
}

/// Build an empty C++1z fold-expression with the given operator.
///
/// By default, produces the fallback value for the fold-expression, or
/// produce an error if there is no fallback value.
ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
                                   BinaryOperatorKind Operator) {
  return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
}

/// Build a new atomic operation expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs,
                             AtomicExpr::AtomicOp Op,
                             SourceLocation RParenLoc) {
  // Use this for all of the locations, since we don't know the difference
  // between the call and the expr at this point.
  SourceRange Range{BuiltinLoc, RParenLoc};
  return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
                                   Sema::AtomicArgumentOrder::AST);
}

3321private:
TypeLoc TransformTypeInObjectScope(TypeLoc TL,
                                   QualType ObjectType,
                                   NamedDecl *FirstQualifierInScope,
                                   CXXScopeSpec &SS);

TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                           QualType ObjectType,
                                           NamedDecl *FirstQualifierInScope,
                                           CXXScopeSpec &SS);

TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
                                          NamedDecl *FirstQualifierInScope,
                                          CXXScopeSpec &SS);

QualType TransformDependentNameType(TypeLocBuilder &TLB,
                                    DependentNameTypeLoc TL,
                                    bool DeducibleTSTContext);
3339};

3341template <typename Derived>
3342StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
if (!S)
  return S;

switch (S->getStmtClass()) {
case Stmt::NoStmtClass: break;

// Transform individual statement nodes
// Pass SDK into statements that can produce a value
3351#define STMT(Node, Parent)                                              \
case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3353#define VALUESTMT(Node, Parent)                                         \
case Stmt::Node##Class:                                               \
  return getDerived().Transform##Node(cast<Node>(S), SDK);
3356#define ABSTRACT_STMT(Node)
3357#define EXPR(Node, Parent)
3358#include "clang/AST/StmtNodes.inc"

// Transform expressions by calling TransformExpr.
3361#define STMT(Node, Parent)
3362#define ABSTRACT_STMT(Stmt)
3363#define EXPR(Node, Parent) case Stmt::Node##Class:
3364#include "clang/AST/StmtNodes.inc"
  {
    ExprResult E = getDerived().TransformExpr(cast<Expr>(S));

    if (SDK == SDK_StmtExprResult)
      E = getSema().ActOnStmtExprResult(E);
    return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
  }
}

return S;
3375}

3377template<typename Derived>
3378OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
if (!S)
  return S;

switch (S->getClauseKind()) {
default: break;
// Transform individual clause nodes
3385#define OPENMP_CLAUSE(Name, Class)                                             \
case OMPC_ ## Name :                                                         \
  return getDerived().Transform ## Class(cast<Class>(S));
3388#include "clang/Basic/OpenMPKinds.def"
}

return S;
3392}


3395template<typename Derived>
3396ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
if (!E)
  return E;

switch (E->getStmtClass()) {
  case Stmt::NoStmtClass: break;
3402#define STMT(Node, Parent) case Stmt::Node##Class: break;
3403#define ABSTRACT_STMT(Stmt)
3404#define EXPR(Node, Parent)                                              \
  case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3406#include "clang/AST/StmtNodes.inc"
}

return E;
3410}

3412template<typename Derived>
3413ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
                                                      bool NotCopyInit) {
// Initializers are instantiated like expressions, except that various outer
// layers are stripped.
if (!Init)
  return Init;

if (auto *FE = dyn_cast<FullExpr>(Init))
  Init = FE->getSubExpr();

if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init))
  Init = AIL->getCommonExpr();

if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
  Init = MTE->GetTemporaryExpr();

while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
  Init = Binder->getSubExpr();

if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
  Init = ICE->getSubExprAsWritten();

if (CXXStdInitializerListExpr *ILE =
        dyn_cast<CXXStdInitializerListExpr>(Init))
  return TransformInitializer(ILE->getSubExpr(), NotCopyInit);

// If this is copy-initialization, we only need to reconstruct
// InitListExprs. Other forms of copy-initialization will be a no-op if
// the initializer is already the right type.
CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);
if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
  return getDerived().TransformExpr(Init);

// Revert value-initialization back to empty parens.
if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) {
  SourceRange Parens = VIE->getSourceRange();
  return getDerived().RebuildParenListExpr(Parens.getBegin(), None,
                                           Parens.getEnd());
}

// FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
if (isa<ImplicitValueInitExpr>(Init))
  return getDerived().RebuildParenListExpr(SourceLocation(), None,
                                           SourceLocation());

// Revert initialization by constructor back to a parenthesized or braced list
// of expressions. Any other form of initializer can just be reused directly.
if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
  return getDerived().TransformExpr(Init);

// If the initialization implicitly converted an initializer list to a
// std::initializer_list object, unwrap the std::initializer_list too.
if (Construct && Construct->isStdInitListInitialization())
  return TransformInitializer(Construct->getArg(0), NotCopyInit);

// Enter a list-init context if this was list initialization.
EnterExpressionEvaluationContext Context(
    getSema(), EnterExpressionEvaluationContext::InitList,
    Construct->isListInitialization());

SmallVector<Expr*, 8> NewArgs;
bool ArgChanged = false;
if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
                                /*IsCall*/true, NewArgs, &ArgChanged))
  return ExprError();

// If this was list initialization, revert to syntactic list form.
if (Construct->isListInitialization())
  return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs,
                                      Construct->getEndLoc());

// Build a ParenListExpr to represent anything else.
SourceRange Parens = Construct->getParenOrBraceRange();
if (Parens.isInvalid()) {
  // This was a variable declaration's initialization for which no initializer
  // was specified.
  assert(NewArgs.empty() &&((NewArgs.empty() && "no parens or braces but have direct init with arguments?"
) ? static_cast<void> (0) : __assert_fail ("NewArgs.empty() && \"no parens or braces but have direct init with arguments?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3490, __PRETTY_FUNCTION__))
         "no parens or braces but have direct init with arguments?")((NewArgs.empty() && "no parens or braces but have direct init with arguments?"
) ? static_cast<void> (0) : __assert_fail ("NewArgs.empty() && \"no parens or braces but have direct init with arguments?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3490, __PRETTY_FUNCTION__));
  return ExprEmpty();
}
return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
                                         Parens.getEnd());
3495}

3497template<typename Derived>
3498bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
                                          unsigned NumInputs,
                                          bool IsCall,
                                    SmallVectorImpl<Expr *> &Outputs,
                                          bool *ArgChanged) {
for (unsigned I = 0; I != NumInputs; ++I) {
  // If requested, drop call arguments that need to be dropped.
  if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
    if (ArgChanged)
      *ArgChanged = true;

    break;
  }

  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
    Expr *Pattern = Expansion->getPattern();

    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? static_cast<void> (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3517, __PRETTY_FUNCTION__));

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
    Optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
                                             Pattern->getSourceRange(),
                                             Unexpanded,
                                             Expand, RetainExpansion,
                                             NumExpansions))
      return true;

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      ExprResult OutPattern = getDerived().TransformExpr(Pattern);
      if (OutPattern.isInvalid())
        return true;

      ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
                                              Expansion->getEllipsisLoc(),
                                                         NumExpansions);
      if (Out.isInvalid())
        return true;

      if (ArgChanged)
        *ArgChanged = true;
      Outputs.push_back(Out.get());
      continue;
    }

    // Record right away that the argument was changed.  This needs
    // to happen even if the array expands to nothing.
    if (ArgChanged) *ArgChanged = true;

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
      ExprResult Out = getDerived().TransformExpr(Pattern);
      if (Out.isInvalid())
        return true;

      if (Out.get()->containsUnexpandedParameterPack()) {
        Out = getDerived().RebuildPackExpansion(
            Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
        if (Out.isInvalid())
          return true;
      }

      Outputs.push_back(Out.get());
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());

      ExprResult Out = getDerived().TransformExpr(Pattern);
      if (Out.isInvalid())
        return true;

      Out = getDerived().RebuildPackExpansion(
          Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
      if (Out.isInvalid())
        return true;

      Outputs.push_back(Out.get());
    }

    continue;
  }

  ExprResult Result =
    IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
           : getDerived().TransformExpr(Inputs[I]);
  if (Result.isInvalid())
    return true;

  if (Result.get() != Inputs[I] && ArgChanged)
    *ArgChanged = true;

  Outputs.push_back(Result.get());
}

return false;
3608}

3610template <typename Derived>
3611Sema::ConditionResult TreeTransform<Derived>::TransformCondition(
  SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
if (Var) {
  VarDecl *ConditionVar = cast_or_null<VarDecl>(
      getDerived().TransformDefinition(Var->getLocation(), Var));

  if (!ConditionVar)
    return Sema::ConditionError();

  return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
}

if (Expr) {
  ExprResult CondExpr = getDerived().TransformExpr(Expr);

  if (CondExpr.isInvalid())
    return Sema::ConditionError();

  return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind);
}

return Sema::ConditionResult();
3633}

3635template<typename Derived>
3636NestedNameSpecifierLoc
3637TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
                                                  NestedNameSpecifierLoc NNS,
                                                   QualType ObjectType,
                                           NamedDecl *FirstQualifierInScope) {
SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
     Qualifier = Qualifier.getPrefix())
  Qualifiers.push_back(Qualifier);

CXXScopeSpec SS;
while (!Qualifiers.empty()) {
  NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
  NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();

  switch (QNNS->getKind()) {
  case NestedNameSpecifier::Identifier: {
    Sema::NestedNameSpecInfo IdInfo(QNNS->getAsIdentifier(),
                        Q.getLocalBeginLoc(), Q.getLocalEndLoc(), ObjectType);
    if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, IdInfo, false,
                                            SS, FirstQualifierInScope, false))
      return NestedNameSpecifierLoc();
  }
    break;

  case NestedNameSpecifier::Namespace: {
    NamespaceDecl *NS
      = cast_or_null<NamespaceDecl>(
                                  getDerived().TransformDecl(
                                                        Q.getLocalBeginLoc(),
                                                     QNNS->getAsNamespace()));
    SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
    break;
  }

  case NestedNameSpecifier::NamespaceAlias: {
    NamespaceAliasDecl *Alias
      = cast_or_null<NamespaceAliasDecl>(
                    getDerived().TransformDecl(Q.getLocalBeginLoc(),
                                               QNNS->getAsNamespaceAlias()));
    SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
              Q.getLocalEndLoc());
    break;
  }

  case NestedNameSpecifier::Global:
    // There is no meaningful transformation that one could perform on the
    // global scope.
    SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
    break;

  case NestedNameSpecifier::Super: {
    CXXRecordDecl *RD =
        cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
            SourceLocation(), QNNS->getAsRecordDecl()));
    SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc());
    break;
  }

  case NestedNameSpecifier::TypeSpecWithTemplate:
  case NestedNameSpecifier::TypeSpec: {
    TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
                                            FirstQualifierInScope, SS);

    if (!TL)
      return NestedNameSpecifierLoc();

    if (TL.getType()->isDependentType() || TL.getType()->isRecordType() ||
        (SemaRef.getLangOpts().CPlusPlus11 &&
         TL.getType()->isEnumeralType())) {
      assert(!TL.getType().hasLocalQualifiers() &&((!TL.getType().hasLocalQualifiers() && "Can't get cv-qualifiers here"
) ? static_cast<void> (0) : __assert_fail ("!TL.getType().hasLocalQualifiers() && \"Can't get cv-qualifiers here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3707, __PRETTY_FUNCTION__))
             "Can't get cv-qualifiers here")((!TL.getType().hasLocalQualifiers() && "Can't get cv-qualifiers here"
) ? static_cast<void> (0) : __assert_fail ("!TL.getType().hasLocalQualifiers() && \"Can't get cv-qualifiers here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3707, __PRETTY_FUNCTION__));
      if (TL.getType()->isEnumeralType())
        SemaRef.Diag(TL.getBeginLoc(),
                     diag::warn_cxx98_compat_enum_nested_name_spec);
      SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL,
                Q.getLocalEndLoc());
      break;
    }
    // If the nested-name-specifier is an invalid type def, don't emit an
    // error because a previous error should have already been emitted.
    TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>();
    if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
      SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
        << TL.getType() << SS.getRange();
    }
    return NestedNameSpecifierLoc();
  }
  }

  // The qualifier-in-scope and object type only apply to the leftmost entity.
  FirstQualifierInScope = nullptr;
  ObjectType = QualType();
}

// Don't rebuild the nested-name-specifier if we don't have to.
if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
    !getDerived().AlwaysRebuild())
  return NNS;

// If we can re-use the source-location data from the original
// nested-name-specifier, do so.
if (SS.location_size() == NNS.getDataLength() &&
    memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
  return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());

// Allocate new nested-name-specifier location information.
return SS.getWithLocInContext(SemaRef.Context);
3744}

3746template<typename Derived>
3747DeclarationNameInfo
3748TreeTransform<Derived>
:TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
DeclarationName Name = NameInfo.getName();
if (!Name)
  return DeclarationNameInfo();

switch (Name.getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXOperatorName:
case DeclarationName::CXXLiteralOperatorName:
case DeclarationName::CXXUsingDirective:
  return NameInfo;

case DeclarationName::CXXDeductionGuideName: {
  TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
  TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
      getDerived().TransformDecl(NameInfo.getLoc(), OldTemplate));
  if (!NewTemplate)
    return DeclarationNameInfo();

  DeclarationNameInfo NewNameInfo(NameInfo);
  NewNameInfo.setName(
      SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(NewTemplate));
  return NewNameInfo;
}

case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
  TypeSourceInfo *NewTInfo;
  CanQualType NewCanTy;
  if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
    NewTInfo = getDerived().TransformType(OldTInfo);
    if (!NewTInfo)
      return DeclarationNameInfo();
    NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
  }
  else {
    NewTInfo = nullptr;
    TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
    QualType NewT = getDerived().TransformType(Name.getCXXNameType());
    if (NewT.isNull())
      return DeclarationNameInfo();
    NewCanTy = SemaRef.Context.getCanonicalType(NewT);
  }

  DeclarationName NewName
    = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
                                                         NewCanTy);
  DeclarationNameInfo NewNameInfo(NameInfo);
  NewNameInfo.setName(NewName);
  NewNameInfo.setNamedTypeInfo(NewTInfo);
  return NewNameInfo;
}
}

llvm_unreachable("Unknown name kind.")::llvm::llvm_unreachable_internal("Unknown name kind.", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3807);
3808}

3810template<typename Derived>
3811TemplateName
3812TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
                                            TemplateName Name,
                                            SourceLocation NameLoc,
                                            QualType ObjectType,
                                            NamedDecl *FirstQualifierInScope,
                                            bool AllowInjectedClassName) {
if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
  TemplateDecl *Template = QTN->getTemplateDecl();
  assert(Template && "qualified template name must refer to a template")((Template && "qualified template name must refer to a template"
) ? static_cast<void> (0) : __assert_fail ("Template && \"qualified template name must refer to a template\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3820, __PRETTY_FUNCTION__));

  TemplateDecl *TransTemplate
    = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
                                                            Template));
  if (!TransTemplate)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      SS.getScopeRep() == QTN->getQualifier() &&
      TransTemplate == Template)
    return Name;

  return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
                                          TransTemplate);
}

if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
  if (SS.getScopeRep()) {
    // These apply to the scope specifier, not the template.
    ObjectType = QualType();
    FirstQualifierInScope = nullptr;
  }

  if (!getDerived().AlwaysRebuild() &&
      SS.getScopeRep() == DTN->getQualifier() &&
      ObjectType.isNull())
    return Name;

  // FIXME: Preserve the location of the "template" keyword.
  SourceLocation TemplateKWLoc = NameLoc;

  if (DTN->isIdentifier()) {
    return getDerived().RebuildTemplateName(SS,
                                            TemplateKWLoc,
                                            *DTN->getIdentifier(),
                                            NameLoc,
                                            ObjectType,
                                            FirstQualifierInScope,
                                            AllowInjectedClassName);
  }

  return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
                                          DTN->getOperator(), NameLoc,
                                          ObjectType, AllowInjectedClassName);
}

if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
  TemplateDecl *TransTemplate
    = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
                                                            Template));
  if (!TransTemplate)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      TransTemplate == Template)
    return Name;

  return TemplateName(TransTemplate);
}

if (SubstTemplateTemplateParmPackStorage *SubstPack
    = Name.getAsSubstTemplateTemplateParmPack()) {
  TemplateTemplateParmDecl *TransParam
  = cast_or_null<TemplateTemplateParmDecl>(
          getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
  if (!TransParam)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      TransParam == SubstPack->getParameterPack())
    return Name;

  return getDerived().RebuildTemplateName(TransParam,
                                          SubstPack->getArgumentPack());
}

// These should be getting filtered out before they reach the AST.
llvm_unreachable("overloaded function decl survived to here")::llvm::llvm_unreachable_internal("overloaded function decl survived to here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3898);
3899}

3901template<typename Derived>
3902void TreeTransform<Derived>::InventTemplateArgumentLoc(
                                       const TemplateArgument &Arg,
                                       TemplateArgumentLoc &Output) {
SourceLocation Loc = getDerived().getBaseLocation();
switch (Arg.getKind()) {
case TemplateArgument::Null:
  llvm_unreachable("null template argument in TreeTransform")::llvm::llvm_unreachable_internal("null template argument in TreeTransform"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3908);
  break;

case TemplateArgument::Type:
  Output = TemplateArgumentLoc(Arg,
             SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));

  break;

case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion: {
  NestedNameSpecifierLocBuilder Builder;
  TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
    Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc);
  else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
    Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc);

  if (Arg.getKind() == TemplateArgument::Template)
    Output = TemplateArgumentLoc(Arg,
                                 Builder.getWithLocInContext(SemaRef.Context),
                                 Loc);
  else
    Output = TemplateArgumentLoc(Arg,
                                 Builder.getWithLocInContext(SemaRef.Context),
                                 Loc, Loc);

  break;
}

case TemplateArgument::Expression:
  Output = TemplateArgumentLoc(Arg, Arg.getAsExpr());
  break;

case TemplateArgument::Declaration:
case TemplateArgument::Integral:
case TemplateArgument::Pack:
case TemplateArgument::NullPtr:
  Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
  break;
}
3949}

3951template<typename Derived>
3952bool TreeTransform<Derived>::TransformTemplateArgument(
                                       const TemplateArgumentLoc &Input,
                                       TemplateArgumentLoc &Output, bool Uneval) {
const TemplateArgument &Arg = Input.getArgument();
switch (Arg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Integral:
case TemplateArgument::Pack:
case TemplateArgument::Declaration:
case TemplateArgument::NullPtr:
  llvm_unreachable("Unexpected TemplateArgument")::llvm::llvm_unreachable_internal("Unexpected TemplateArgument"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3962);

case TemplateArgument::Type: {
  TypeSourceInfo *DI = Input.getTypeSourceInfo();
  if (!DI)
    DI = InventTypeSourceInfo(Input.getArgument().getAsType());

  DI = getDerived().TransformType(DI);
  if (!DI) return true;

  Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
  return false;
}

case TemplateArgument::Template: {
  NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
  if (QualifierLoc) {
    QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
    if (!QualifierLoc)
      return true;
  }

  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  TemplateName Template
    = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(),
                                         Input.getTemplateNameLoc());
  if (Template.isNull())
    return true;

  Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc,
                               Input.getTemplateNameLoc());
  return false;
}

case TemplateArgument::TemplateExpansion:
  llvm_unreachable("Caller should expand pack expansions")::llvm::llvm_unreachable_internal("Caller should expand pack expansions"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 3998);

case TemplateArgument::Expression: {
  // Template argument expressions are constant expressions.
  EnterExpressionEvaluationContext Unevaluated(
      getSema(),
      Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
             : Sema::ExpressionEvaluationContext::ConstantEvaluated,
      /*LambdaContextDecl=*/nullptr, /*ExprContext=*/
      Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);

  Expr *InputExpr = Input.getSourceExpression();
  if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();

  ExprResult E = getDerived().TransformExpr(InputExpr);
  E = SemaRef.ActOnConstantExpression(E);
  if (E.isInvalid()) return true;
  Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
  return false;
}
}

// Work around bogus GCC warning
return true;
4022}

4024/// Iterator adaptor that invents template argument location information
4025/// for each of the template arguments in its underlying iterator.
4026template<typename Derived, typename InputIterator>
4027class TemplateArgumentLocInventIterator {
TreeTransform<Derived> &Self;
InputIterator Iter;

4031public:
typedef TemplateArgumentLoc value_type;
typedef TemplateArgumentLoc reference;
typedef typename std::iterator_traits<InputIterator>::difference_type
  difference_type;
typedef std::input_iterator_tag iterator_category;

class pointer {
  TemplateArgumentLoc Arg;

public:
  explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }

  const TemplateArgumentLoc *operator->() const { return &Arg; }
};

TemplateArgumentLocInventIterator() { }

explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
                                           InputIterator Iter)
  : Self(Self), Iter(Iter) { }

TemplateArgumentLocInventIterator &operator++() {
  ++Iter;
  return *this;
}

TemplateArgumentLocInventIterator operator++(int) {
  TemplateArgumentLocInventIterator Old(*this);
  ++(*this);
  return Old;
}

reference operator*() const {
  TemplateArgumentLoc Result;
  Self.InventTemplateArgumentLoc(*Iter, Result);
  return Result;
}

pointer operator->() const { return pointer(**this); }

friend bool operator==(const TemplateArgumentLocInventIterator &X,
                       const TemplateArgumentLocInventIterator &Y) {
  return X.Iter == Y.Iter;
}

friend bool operator!=(const TemplateArgumentLocInventIterator &X,
                       const TemplateArgumentLocInventIterator &Y) {
  return X.Iter != Y.Iter;
}
4081};

4083template<typename Derived>
4084template<typename InputIterator>
4085bool TreeTransform<Derived>::TransformTemplateArguments(
  InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
  bool Uneval) {
for (; First != Last; ++First) {
  TemplateArgumentLoc Out;
  TemplateArgumentLoc In = *First;

  if (In.getArgument().getKind() == TemplateArgument::Pack) {
    // Unpack argument packs, which we translate them into separate
    // arguments.
    // FIXME: We could do much better if we could guarantee that the
    // TemplateArgumentLocInfo for the pack expansion would be usable for
    // all of the template arguments in the argument pack.
    typedef TemplateArgumentLocInventIterator<Derived,
                                              TemplateArgument::pack_iterator>
      PackLocIterator;
    if (TransformTemplateArguments(PackLocIterator(*this,
                                               In.getArgument().pack_begin()),
                                   PackLocIterator(*this,
                                                 In.getArgument().pack_end()),
                                   Outputs, Uneval))
      return true;

    continue;
  }

  if (In.getArgument().isPackExpansion()) {
    // We have a pack expansion, for which we will be substituting into
    // the pattern.
    SourceLocation Ellipsis;
    Optional<unsigned> OrigNumExpansions;
    TemplateArgumentLoc Pattern
      = getSema().getTemplateArgumentPackExpansionPattern(
            In, Ellipsis, OrigNumExpansions);

    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? static_cast<void> (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 4122, __PRETTY_FUNCTION__));

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    Optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(Ellipsis,
                                             Pattern.getSourceRange(),
                                             Unexpanded,
                                             Expand,
                                             RetainExpansion,
                                             NumExpansions))
      return true;

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      TemplateArgumentLoc OutPattern;
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
        return true;

      Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
                                              NumExpansions);
      if (Out.getArgument().isNull())
        return true;

      Outputs.addArgument(Out);
      continue;
    }

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);

      if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
        return true;

      if (Out.getArgument().containsUnexpandedParameterPack()) {
        Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
                                                OrigNumExpansions);
        if (Out.getArgument().isNull())
          return true;
      }

      Outputs.addArgument(Out);
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());

      if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
        return true;

      Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
                                              OrigNumExpansions);
      if (Out.getArgument().isNull())
        return true;

      Outputs.addArgument(Out);
    }

    continue;
  }

  // The simple case:
  if (getDerived().TransformTemplateArgument(In, Out, Uneval))
    return true;

  Outputs.addArgument(Out);
}

return false;

4201}

4203//===----------------------------------------------------------------------===//
4204// Type transformation
4205//===----------------------------------------------------------------------===//

4207template<typename Derived>
4208QualType TreeTransform<Derived>::TransformType(QualType T) {
if (getDerived().AlreadyTransformed(T))
  return T;

// Temporary workaround.  All of these transformations should
// eventually turn into transformations on TypeLocs.
TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
                                              getDerived().getBaseLocation());

TypeSourceInfo *NewDI = getDerived().TransformType(DI);

if (!NewDI)
  return QualType();

return NewDI->getType();
4223}

4225template<typename Derived>
4226TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) {
// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
                     getDerived().getBaseEntity());
if (getDerived().AlreadyTransformed(DI->getType()))
  return DI;

TypeLocBuilder TLB;

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

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

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

4245template<typename Derived>
4246QualType
4247TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
switch (T.getTypeLocClass()) {
2
←
Control jumps to 'case VariableArray:'  at line 72→
5
←
Control jumps to 'case RValueReference:'  at line 59→
4249#define ABSTRACT_TYPELOC(CLASS, PARENT)
4250#define TYPELOC(CLASS, PARENT)                                                 \
case TypeLoc::CLASS:                                                         \
  return getDerived().Transform##CLASS##Type(TLB,                            \
                                             T.castAs<CLASS##TypeLoc>());
4254#include "clang/AST/TypeLocNodes.def"
}

llvm_unreachable("unhandled type loc!")::llvm::llvm_unreachable_internal("unhandled type loc!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 4257);
4258}

4260template<typename Derived>
4261QualType TreeTransform<Derived>::TransformTypeWithDeducedTST(QualType T) {
if (!isa<DependentNameType>(T))
  return TransformType(T);

if (getDerived().AlreadyTransformed(T))
  return T;
TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
                                              getDerived().getBaseLocation());
TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
return NewDI ? NewDI->getType() : QualType();
4271}

4273template<typename Derived>
4274TypeSourceInfo *
4275TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *DI) {
if (!isa<DependentNameType>(DI->getType()))
  return TransformType(DI);

// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
                     getDerived().getBaseEntity());
if (getDerived().AlreadyTransformed(DI->getType()))
  return DI;

TypeLocBuilder TLB;

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

auto QTL = TL.getAs<QualifiedTypeLoc>();
if (QTL)
  TL = QTL.getUnqualifiedLoc();

auto DNTL = TL.castAs<DependentNameTypeLoc>();

QualType Result = getDerived().TransformDependentNameType(
    TLB, DNTL, /*DeducedTSTContext*/true);
if (Result.isNull())
  return nullptr;

if (QTL) {
  Result = getDerived().RebuildQualifiedType(Result, QTL);
  if (Result.isNull())
    return nullptr;
  TLB.TypeWasModifiedSafely(Result);
}

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

4311template<typename Derived>
4312QualType
4313TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
                                             QualifiedTypeLoc T) {
QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc());
if (Result.isNull())
  return QualType();

Result = getDerived().RebuildQualifiedType(Result, T);

if (Result.isNull())
  return QualType();

// RebuildQualifiedType might have updated the type, but not in a way
// that invalidates the TypeLoc. (There's no location information for
// qualifiers.)
TLB.TypeWasModifiedSafely(Result);

return Result;
4330}

4332template <typename Derived>
4333QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
                                                    QualifiedTypeLoc TL) {

SourceLocation Loc = TL.getBeginLoc();
Qualifiers Quals = TL.getType().getLocalQualifiers();

if (((T.getAddressSpace() != LangAS::Default &&
      Quals.getAddressSpace() != LangAS::Default)) &&
    T.getAddressSpace() != Quals.getAddressSpace()) {
  SemaRef.Diag(Loc, diag::err_address_space_mismatch_templ_inst)
      << TL.getType() << T;
  return QualType();
}

// C++ [dcl.fct]p7:
//   [When] adding cv-qualifications on top of the function type [...] the
//   cv-qualifiers are ignored.
if (T->isFunctionType()) {
  T = SemaRef.getASTContext().getAddrSpaceQualType(T,
                                                   Quals.getAddressSpace());
  return T;
}

// C++ [dcl.ref]p1:
//   when the cv-qualifiers are introduced through the use of a typedef-name
//   or decltype-specifier [...] the cv-qualifiers are ignored.
// Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be
// applied to a reference type.
if (T->isReferenceType()) {
  // The only qualifier that applies to a reference type is restrict.
  if (!Quals.hasRestrict())
    return T;
  Quals = Qualifiers::fromCVRMask(Qualifiers::Restrict);
}

// Suppress Objective-C lifetime qualifiers if they don't make sense for the
// resulting type.
if (Quals.hasObjCLifetime()) {
  if (!T->isObjCLifetimeType() && !T->isDependentType())
    Quals.removeObjCLifetime();
  else if (T.getObjCLifetime()) {
    // Objective-C ARC:
    //   A lifetime qualifier applied to a substituted template parameter
    //   overrides the lifetime qualifier from the template argument.
    const AutoType *AutoTy;
    if (const SubstTemplateTypeParmType *SubstTypeParam
                              = dyn_cast<SubstTemplateTypeParmType>(T)) {
      QualType Replacement = SubstTypeParam->getReplacementType();
      Qualifiers Qs = Replacement.getQualifiers();
      Qs.removeObjCLifetime();
      Replacement = SemaRef.Context.getQualifiedType(
          Replacement.getUnqualifiedType(), Qs);
      T = SemaRef.Context.getSubstTemplateTypeParmType(
          SubstTypeParam->getReplacedParameter(), Replacement);
    } else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
      // 'auto' types behave the same way as template parameters.
      QualType Deduced = AutoTy->getDeducedType();
      Qualifiers Qs = Deduced.getQualifiers();
      Qs.removeObjCLifetime();
      Deduced =
          SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), Qs);
      T = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
                                      AutoTy->isDependentType());
    } else {
      // Otherwise, complain about the addition of a qualifier to an
      // already-qualified type.
      // FIXME: Why is this check not in Sema::BuildQualifiedType?
      SemaRef.Diag(Loc, diag::err_attr_objc_ownership_redundant) << T;
      Quals.removeObjCLifetime();
    }
  }
}

return SemaRef.BuildQualifiedType(T, Loc, Quals);
4407}

4409template<typename Derived>
4410TypeLoc
4411TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
                                                 QualType ObjectType,
                                                 NamedDecl *UnqualLookup,
                                                 CXXScopeSpec &SS) {
if (getDerived().AlreadyTransformed(TL.getType()))
  return TL;

TypeSourceInfo *TSI =
    TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
if (TSI)
  return TSI->getTypeLoc();
return TypeLoc();
4423}

4425template<typename Derived>
4426TypeSourceInfo *
4427TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                                 QualType ObjectType,
                                                 NamedDecl *UnqualLookup,
                                                 CXXScopeSpec &SS) {
if (getDerived().AlreadyTransformed(TSInfo->getType()))
  return TSInfo;

return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
                                 UnqualLookup, SS);
4436}

4438template <typename Derived>
4439TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
  TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
  CXXScopeSpec &SS) {
QualType T = TL.getType();
assert(!getDerived().AlreadyTransformed(T))((!getDerived().AlreadyTransformed(T)) ? static_cast<void>
 (0) : __assert_fail ("!getDerived().AlreadyTransformed(T)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 4443, __PRETTY_FUNCTION__));

TypeLocBuilder TLB;
QualType Result;

if (isa<TemplateSpecializationType>(T)) {
  TemplateSpecializationTypeLoc SpecTL =
      TL.castAs<TemplateSpecializationTypeLoc>();

  TemplateName Template = getDerived().TransformTemplateName(
      SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
      ObjectType, UnqualLookup, /*AllowInjectedClassName*/true);
  if (Template.isNull())
    return nullptr;

  Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
                                                            Template);
} else if (isa<DependentTemplateSpecializationType>(T)) {
  DependentTemplateSpecializationTypeLoc SpecTL =
      TL.castAs<DependentTemplateSpecializationTypeLoc>();

  TemplateName Template
    = getDerived().RebuildTemplateName(SS,
                                       SpecTL.getTemplateKeywordLoc(),
                                       *SpecTL.getTypePtr()->getIdentifier(),
                                       SpecTL.getTemplateNameLoc(),
                                       ObjectType, UnqualLookup,
                                       /*AllowInjectedClassName*/true);
  if (Template.isNull())
    return nullptr;

  Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
                                                                     SpecTL,
                                                                     Template,
                                                                     SS);
} else {
  // Nothing special needs to be done for these.
  Result = getDerived().TransformType(TLB, TL);
}

if (Result.isNull())
  return nullptr;

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

4489template <class TyLoc> static inline
4490QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
TyLoc NewT = TLB.push<TyLoc>(T.getType());
NewT.setNameLoc(T.getNameLoc());
return T.getType();
4494}

4496template<typename Derived>
4497QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
                                                    BuiltinTypeLoc T) {
BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
NewT.setBuiltinLoc(T.getBuiltinLoc());
if (T.needsExtraLocalData())
  NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
return T.getType();
4504}

4506template<typename Derived>
4507QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
                                                    ComplexTypeLoc T) {
// FIXME: recurse?
return TransformTypeSpecType(TLB, T);
4511}

4513template <typename Derived>
4514QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
                                                     AdjustedTypeLoc TL) {
// Adjustments applied during transformation are handled elsewhere.
return getDerived().TransformType(TLB, TL.getOriginalLoc());
4518}

4520template<typename Derived>
4521QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
                                                    DecayedTypeLoc TL) {
QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
if (OriginalType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    OriginalType != TL.getOriginalLoc().getType())
  Result = SemaRef.Context.getDecayedType(OriginalType);
TLB.push<DecayedTypeLoc>(Result);
// Nothing to set for DecayedTypeLoc.
return Result;
4534}

4536/// Helper to deduce addr space of a pointee type in OpenCL mode.
4537/// If the type is updated it will be overwritten in PointeeType param.
4538static void deduceOpenCLPointeeAddrSpace(Sema &SemaRef, QualType &PointeeType) {
if (PointeeType.getAddressSpace() == LangAS::Default)
  PointeeType = SemaRef.Context.getAddrSpaceQualType(PointeeType,
                                                     LangAS::opencl_generic);
4542}

4544template<typename Derived>
4545QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
                                                    PointerTypeLoc TL) {
QualType PointeeType
  = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

if (SemaRef.getLangOpts().OpenCL)
  deduceOpenCLPointeeAddrSpace(SemaRef, PointeeType);

QualType Result = TL.getType();
if (PointeeType->getAs<ObjCObjectType>()) {
  // A dependent pointer type 'T *' has is being transformed such
  // that an Objective-C class type is being replaced for 'T'. The
  // resulting pointer type is an ObjCObjectPointerType, not a
  // PointerType.
  Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);

  ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
  NewT.setStarLoc(TL.getStarLoc());
  return Result;
}

if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

// Objective-C ARC can add lifetime qualifiers to the type that we're
// pointing to.
TLB.TypeWasModifiedSafely(Result->getPointeeType());

PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
NewT.setSigilLoc(TL.getSigilLoc());
return Result;
4582}

4584template<typename Derived>
4585QualType
4586TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
                                                BlockPointerTypeLoc TL) {
QualType PointeeType
  = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

if (SemaRef.getLangOpts().OpenCL)
  deduceOpenCLPointeeAddrSpace(SemaRef, PointeeType);

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildBlockPointerType(PointeeType,
                                                TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
NewT.setSigilLoc(TL.getSigilLoc());
return Result;
4608}

4610/// Transforms a reference type.  Note that somewhat paradoxically we
4611/// don't care whether the type itself is an l-value type or an r-value
4612/// type;  we only care if the type was *written* as an l-value type
4613/// or an r-value type.
4614template<typename Derived>
4615QualType
4616TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
                                             ReferenceTypeLoc TL) {
const ReferenceType *T = TL.getTypePtr();

// Note that this works with the pointee-as-written.
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
8
←
Calling 'QualType::isNull'→
14
←
Returning from 'QualType::isNull'→
15
←
Taking false branch→
  return QualType();

if (SemaRef.getLangOpts().OpenCL)
16
←
Assuming field 'OpenCL' is 0→
17
←
Taking false branch→
  deduceOpenCLPointeeAddrSpace(SemaRef, PointeeType);

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
18
←
Taking false branch→
    PointeeType != T->getPointeeTypeAsWritten()) {
  Result = getDerived().RebuildReferenceType(PointeeType,
                                             T->isSpelledAsLValue(),
                                             TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

// Objective-C ARC can add lifetime qualifiers to the type that we're
// referring to.
TLB.TypeWasModifiedSafely(
                   Result->getAs<ReferenceType>()->getPointeeTypeAsWritten());
19
←
Assuming the object is not a 'ReferenceType'→
20
←
Called C++ object pointer is null

// r-value references can be rebuilt as l-value references.
ReferenceTypeLoc NewTL;
if (isa<LValueReferenceType>(Result))
  NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
else
  NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());

return Result;
4652}

4654template<typename Derived>
4655QualType
4656TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
                                               LValueReferenceTypeLoc TL) {
return TransformReferenceType(TLB, TL);
4659}

4661template<typename Derived>
4662QualType
4663TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
                                               RValueReferenceTypeLoc TL) {
return TransformReferenceType(TLB, TL);
7
←
Calling 'TreeTransform::TransformReferenceType'→
4666}

4668template<typename Derived>
4669QualType
4670TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
                                                 MemberPointerTypeLoc TL) {
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
TypeSourceInfo *NewClsTInfo = nullptr;
if (OldClsTInfo) {
  NewClsTInfo = getDerived().TransformType(OldClsTInfo);
  if (!NewClsTInfo)
    return QualType();
}

const MemberPointerType *T = TL.getTypePtr();
QualType OldClsType = QualType(T->getClass(), 0);
QualType NewClsType;
if (NewClsTInfo)
  NewClsType = NewClsTInfo->getType();
else {
  NewClsType = getDerived().TransformType(OldClsType);
  if (NewClsType.isNull())
    return QualType();
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != T->getPointeeType() ||
    NewClsType != OldClsType) {
  Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
                                                 TL.getStarLoc());
  if (Result.isNull())
    return QualType();
}

// If we had to adjust the pointee type when building a member pointer, make
// sure to push TypeLoc info for it.
const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
if (MPT && PointeeType != MPT->getPointeeType()) {
  assert(isa<AdjustedType>(MPT->getPointeeType()))((isa<AdjustedType>(MPT->getPointeeType())) ? static_cast
<void> (0) : __assert_fail ("isa<AdjustedType>(MPT->getPointeeType())"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 4709, __PRETTY_FUNCTION__));
  TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
}

MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());
NewTL.setClassTInfo(NewClsTInfo);

return Result;
4718}

4720template<typename Derived>
4721QualType
4722TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
                                                 ConstantArrayTypeLoc TL) {
const ConstantArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildConstantArrayType(ElementType,
                                                 T->getSizeModifier(),
                                                 T->getSize(),
                                           T->getIndexTypeCVRQualifiers(),
                                                 TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have either a ConstantArrayType or a VariableArrayType now:
// a ConstantArrayType is allowed to have an element type which is a
// VariableArrayType if the type is dependent.  Fortunately, all array
// types have the same location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());

Expr *Size = TL.getSizeExpr();
if (Size) {
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  Size = getDerived().TransformExpr(Size).template getAs<Expr>();
  Size = SemaRef.ActOnConstantExpression(Size).get();
}
NewTL.setSizeExpr(Size);

return Result;
4759}

4761template<typename Derived>
4762QualType TreeTransform<Derived>::TransformIncompleteArrayType(
                                            TypeLocBuilder &TLB,
                                            IncompleteArrayTypeLoc TL) {
const IncompleteArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildIncompleteArrayType(ElementType,
                                                   T->getSizeModifier(),
                                         T->getIndexTypeCVRQualifiers(),
                                                   TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(nullptr);

return Result;
4787}

4789template<typename Derived>
4790QualType
4791TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
                                                 VariableArrayTypeLoc TL) {
const VariableArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
4
←
Calling 'TreeTransform::TransformType'→
if (ElementType.isNull())
  return QualType();

ExprResult SizeResult;
{
  EnterExpressionEvaluationContext Context(
      SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
  SizeResult = getDerived().TransformExpr(T->getSizeExpr());
}
if (SizeResult.isInvalid())
  return QualType();
SizeResult =
    SemaRef.ActOnFinishFullExpr(SizeResult.get(), /*DiscardedValue*/ false);
if (SizeResult.isInvalid())
  return QualType();

Expr *Size = SizeResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    Size != T->getSizeExpr()) {
  Result = getDerived().RebuildVariableArrayType(ElementType,
                                                 T->getSizeModifier(),
                                                 Size,
                                           T->getIndexTypeCVRQualifiers(),
                                                 TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have constant size array now, but fortunately it has the same
// location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(Size);

return Result;
4834}

4836template<typename Derived>
4837QualType
4838TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
                                           DependentSizedArrayTypeLoc TL) {
const DependentSizedArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Array bounds are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

// Prefer the expression from the TypeLoc;  the other may have been uniqued.
Expr *origSize = TL.getSizeExpr();
if (!origSize) origSize = T->getSizeExpr();

ExprResult sizeResult
  = getDerived().TransformExpr(origSize);
sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
if (sizeResult.isInvalid())
  return QualType();

Expr *size = sizeResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    size != origSize) {
  Result = getDerived().RebuildDependentSizedArrayType(ElementType,
                                                       T->getSizeModifier(),
                                                       size,
                                              T->getIndexTypeCVRQualifiers(),
                                                      TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have any sort of array type now, but fortunately they
// all have the same location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(size);

return Result;
4882}

4884template <typename Derived>
4885QualType TreeTransform<Derived>::TransformDependentVectorType(
  TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
const DependentVectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull())
  return QualType();

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
Size = SemaRef.ActOnConstantExpression(Size);
if (Size.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
    Size.get() != T->getSizeExpr()) {
  Result = getDerived().RebuildDependentVectorType(
      ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentVectorType>(Result)) {
  DependentVectorTypeLoc NewTL =
      TLB.push<DependentVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}

return Result;
4920}

4922template<typename Derived>
4923QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
                                    TypeLocBuilder &TLB,
                                    DependentSizedExtVectorTypeLoc TL) {
const DependentSizedExtVectorType *T = TL.getTypePtr();

// FIXME: ext vector locs should be nested
QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull())
  return QualType();

// Vector sizes are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
Size = SemaRef.ActOnConstantExpression(Size);
if (Size.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    Size.get() != T->getSizeExpr()) {
  Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
                                                           Size.get(),
                                                       T->getAttributeLoc());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentSizedExtVectorType>(Result)) {
  DependentSizedExtVectorTypeLoc NewTL
    = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}

return Result;
4964}

4966template <typename Derived>
4967QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
  TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
const DependentAddressSpaceType *T = TL.getTypePtr();

QualType pointeeType = getDerived().TransformType(T->getPointeeType());

if (pointeeType.isNull())
  return QualType();

// Address spaces are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
AddrSpace = SemaRef.ActOnConstantExpression(AddrSpace);
if (AddrSpace.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
    AddrSpace.get() != T->getAddrSpaceExpr()) {
  Result = getDerived().RebuildDependentAddressSpaceType(
      pointeeType, AddrSpace.get(), T->getAttributeLoc());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentAddressSpaceType>(Result)) {
  DependentAddressSpaceTypeLoc NewTL =
      TLB.push<DependentAddressSpaceTypeLoc>(Result);

  NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
  NewTL.setAttrExprOperand(TL.getAttrExprOperand());
  NewTL.setAttrNameLoc(TL.getAttrNameLoc());

} else {
  TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
      Result, getDerived().getBaseLocation());
  TransformType(TLB, DI->getTypeLoc());
}

return Result;
5010}

5012template <typename Derived>
5013QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
                                                   VectorTypeLoc TL) {
const VectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
                                          T->getVectorKind());
  if (Result.isNull())
    return QualType();
}

VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5033}

5035template<typename Derived>
5036QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
                                                      ExtVectorTypeLoc TL) {
const VectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildExtVectorType(ElementType,
                                             T->getNumElements(),
                                             /*FIXME*/ SourceLocation());
  if (Result.isNull())
    return QualType();
}

ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5057}

5059template <typename Derived>
5060ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
  ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions,
  bool ExpectParameterPack) {
TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
TypeSourceInfo *NewDI = nullptr;

if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
  // If we're substituting into a pack expansion type and we know the
  // length we want to expand to, just substitute for the pattern.
  TypeLoc OldTL = OldDI->getTypeLoc();
  PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();

  TypeLocBuilder TLB;
  TypeLoc NewTL = OldDI->getTypeLoc();
  TLB.reserve(NewTL.getFullDataSize());

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

  Result = RebuildPackExpansionType(Result,
                              OldExpansionTL.getPatternLoc().getSourceRange(),
                                    OldExpansionTL.getEllipsisLoc(),
                                    NumExpansions);
  if (Result.isNull())
    return nullptr;

  PackExpansionTypeLoc NewExpansionTL
    = TLB.push<PackExpansionTypeLoc>(Result);
  NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
  NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
} else
  NewDI = getDerived().TransformType(OldDI);
if (!NewDI)
  return nullptr;

if (NewDI == OldDI && indexAdjustment == 0)
  return OldParm;

ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context,
                                           OldParm->getDeclContext(),
                                           OldParm->getInnerLocStart(),
                                           OldParm->getLocation(),
                                           OldParm->getIdentifier(),
                                           NewDI->getType(),
                                           NewDI,
                                           OldParm->getStorageClass(),
                                           /* DefArg */ nullptr);
newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
                      OldParm->getFunctionScopeIndex() + indexAdjustment);
return newParm;
5112}

5114template <typename Derived>
5115bool TreeTransform<Derived>::TransformFunctionTypeParams(
  SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
  const QualType *ParamTypes,
  const FunctionProtoType::ExtParameterInfo *ParamInfos,
  SmallVectorImpl<QualType> &OutParamTypes,
  SmallVectorImpl<ParmVarDecl *> *PVars,
  Sema::ExtParameterInfoBuilder &PInfos) {
int indexAdjustment = 0;

unsigned NumParams = Params.size();
for (unsigned i = 0; i != NumParams; ++i) {
  if (ParmVarDecl *OldParm = Params[i]) {
    assert(OldParm->getFunctionScopeIndex() == i)((OldParm->getFunctionScopeIndex() == i) ? static_cast<
void> (0) : __assert_fail ("OldParm->getFunctionScopeIndex() == i"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 5127, __PRETTY_FUNCTION__));

    Optional<unsigned> NumExpansions;
    ParmVarDecl *NewParm = nullptr;
    if (OldParm->isParameterPack()) {
      // We have a function parameter pack that may need to be expanded.
      SmallVector<UnexpandedParameterPack, 2> Unexpanded;

      // Find the parameter packs that could be expanded.
      TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
      PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
      TypeLoc Pattern = ExpansionTL.getPatternLoc();
      SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
      assert(Unexpanded.size() > 0 && "Could not find parameter packs!")((Unexpanded.size() > 0 && "Could not find parameter packs!"
) ? static_cast<void> (0) : __assert_fail ("Unexpanded.size() > 0 && \"Could not find parameter packs!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 5140, __PRETTY_FUNCTION__));

      // Determine whether we should expand the parameter packs.
      bool ShouldExpand = false;
      bool RetainExpansion = false;
      Optional<unsigned> OrigNumExpansions =
          ExpansionTL.getTypePtr()->getNumExpansions();
      NumExpansions = OrigNumExpansions;
      if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                               Pattern.getSourceRange(),
                                               Unexpanded,
                                               ShouldExpand,
                                               RetainExpansion,
                                               NumExpansions)) {
        return true;
      }

      if (ShouldExpand) {
        // Expand the function parameter pack into multiple, separate
        // parameters.
        getDerived().ExpandingFunctionParameterPack(OldParm);
        for (unsigned I = 0; I != *NumExpansions; ++I) {
          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
          ParmVarDecl *NewParm
            = getDerived().TransformFunctionTypeParam(OldParm,
                                                      indexAdjustment++,
                                                      OrigNumExpansions,
                                              /*ExpectParameterPack=*/false);
          if (!NewParm)
            return true;

          if (ParamInfos)
            PInfos.set(OutParamTypes.size(), ParamInfos[i]);
          OutParamTypes.push_back(NewParm->getType());
          if (PVars)
            PVars->push_back(NewParm);
        }

        // If we're supposed to retain a pack expansion, do so by temporarily
        // forgetting the partially-substituted parameter pack.
        if (RetainExpansion) {
          ForgetPartiallySubstitutedPackRAII Forget(getDerived());
          ParmVarDecl *NewParm
            = getDerived().TransformFunctionTypeParam(OldParm,
                                                      indexAdjustment++,
                                                      OrigNumExpansions,
                                              /*ExpectParameterPack=*/false);
          if (!NewParm)
            return true;

          if (ParamInfos)
            PInfos.set(OutParamTypes.size(), ParamInfos[i]);
          OutParamTypes.push_back(NewParm->getType());
          if (PVars)
            PVars->push_back(NewParm);
        }

        // The next parameter should have the same adjustment as the
        // last thing we pushed, but we post-incremented indexAdjustment
        // on every push.  Also, if we push nothing, the adjustment should
        // go down by one.
        indexAdjustment--;

        // We're done with the pack expansion.
        continue;
      }

      // We'll substitute the parameter now without expanding the pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      NewParm = getDerived().TransformFunctionTypeParam(OldParm,
                                                        indexAdjustment,
                                                        NumExpansions,
                                                /*ExpectParameterPack=*/true);
    } else {
      NewParm = getDerived().TransformFunctionTypeParam(
          OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false);
    }

    if (!NewParm)
      return true;

    if (ParamInfos)
      PInfos.set(OutParamTypes.size(), ParamInfos[i]);
    OutParamTypes.push_back(NewParm->getType());
    if (PVars)
      PVars->push_back(NewParm);
    continue;
  }

  // Deal with the possibility that we don't have a parameter
  // declaration for this parameter.
  QualType OldType = ParamTypes[i];
  bool IsPackExpansion = false;
  Optional<unsigned> NumExpansions;
  QualType NewType;
  if (const PackExpansionType *Expansion
                                     = dyn_cast<PackExpansionType>(OldType)) {
    // We have a function parameter pack that may need to be expanded.
    QualType Pattern = Expansion->getPattern();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);

    // Determine whether we should expand the parameter packs.
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    if (getDerived().TryExpandParameterPacks(Loc, SourceRange(),
                                             Unexpanded,
                                             ShouldExpand,
                                             RetainExpansion,
                                             NumExpansions)) {
      return true;
    }

    if (ShouldExpand) {
      // Expand the function parameter pack into multiple, separate
      // parameters.
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        QualType NewType = getDerived().TransformType(Pattern);
        if (NewType.isNull())
          return true;

        if (NewType->containsUnexpandedParameterPack()) {
          NewType =
              getSema().getASTContext().getPackExpansionType(NewType, None);

          if (NewType.isNull())
            return true;
        }

        if (ParamInfos)
          PInfos.set(OutParamTypes.size(), ParamInfos[i]);
        OutParamTypes.push_back(NewType);
        if (PVars)
          PVars->push_back(nullptr);
      }

      // We're done with the pack expansion.
      continue;
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());
      QualType NewType = getDerived().TransformType(Pattern);
      if (NewType.isNull())
        return true;

      if (ParamInfos)
        PInfos.set(OutParamTypes.size(), ParamInfos[i]);
      OutParamTypes.push_back(NewType);
      if (PVars)
        PVars->push_back(nullptr);
    }

    // We'll substitute the parameter now without expanding the pack
    // expansion.
    OldType = Expansion->getPattern();
    IsPackExpansion = true;
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
    NewType = getDerived().TransformType(OldType);
  } else {
    NewType = getDerived().TransformType(OldType);
  }

  if (NewType.isNull())
    return true;

  if (IsPackExpansion)
    NewType = getSema().Context.getPackExpansionType(NewType,
                                                     NumExpansions);

  if (ParamInfos)
    PInfos.set(OutParamTypes.size(), ParamInfos[i]);
  OutParamTypes.push_back(NewType);
  if (PVars)
    PVars->push_back(nullptr);
}

5321#ifndef NDEBUG
if (PVars) {
  for (unsigned i = 0, e = PVars->size(); i != e; ++i)
    if (ParmVarDecl *parm = (*PVars)[i])
      assert(parm->getFunctionScopeIndex() == i)((parm->getFunctionScopeIndex() == i) ? static_cast<void
> (0) : __assert_fail ("parm->getFunctionScopeIndex() == i"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 5325, __PRETTY_FUNCTION__));
}
5327#endif

return false;
5330}

5332template<typename Derived>
5333QualType
5334TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
                                                 FunctionProtoTypeLoc TL) {
SmallVector<QualType, 4> ExceptionStorage;
TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
return getDerived().TransformFunctionProtoType(
    TLB, TL, nullptr, Qualifiers(),
    [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
      return This->TransformExceptionSpec(TL.getBeginLoc(), ESI,
                                          ExceptionStorage, Changed);
    });
5344}

5346template<typename Derived> template<typename Fn>
5347QualType TreeTransform<Derived>::TransformFunctionProtoType(
  TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
  Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {

// Transform the parameters and return type.
//
// We are required to instantiate the params and return type in source order.
// When the function has a trailing return type, we instantiate the
// parameters before the return type,  since the return type can then refer
// to the parameters themselves (via decltype, sizeof, etc.).
//
SmallVector<QualType, 4> ParamTypes;
SmallVector<ParmVarDecl*, 4> ParamDecls;
Sema::ExtParameterInfoBuilder ExtParamInfos;
const FunctionProtoType *T = TL.getTypePtr();

QualType ResultType;

if (T->hasTrailingReturn()) {
  if (getDerived().TransformFunctionTypeParams(
          TL.getBeginLoc(), TL.getParams(),
          TL.getTypePtr()->param_type_begin(),
          T->getExtParameterInfosOrNull(),
          ParamTypes, &ParamDecls, ExtParamInfos))
    return QualType();

  {
    // C++11 [expr.prim.general]p3:
    //   If a declaration declares a member function or member function
    //   template of a class X, the expression this is a prvalue of type
    //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
    //   and the end of the function-definition, member-declarator, or
    //   declarator.
    Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals);

    ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
    if (ResultType.isNull())
      return QualType();
  }
}
else {
  ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
  if (ResultType.isNull())
    return QualType();

  if (getDerived().TransformFunctionTypeParams(
          TL.getBeginLoc(), TL.getParams(),
          TL.getTypePtr()->param_type_begin(),
          T->getExtParameterInfosOrNull(),
          ParamTypes, &ParamDecls, ExtParamInfos))
    return QualType();
}

FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();

bool EPIChanged = false;
if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
  return QualType();

// Handle extended parameter information.
if (auto NewExtParamInfos =
      ExtParamInfos.getPointerOrNull(ParamTypes.size())) {
  if (!EPI.ExtParameterInfos ||
      llvm::makeArrayRef(EPI.ExtParameterInfos, TL.getNumParams())
        != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) {
    EPIChanged = true;
  }
  EPI.ExtParameterInfos = NewExtParamInfos;
} else if (EPI.ExtParameterInfos) {
  EPIChanged = true;
  EPI.ExtParameterInfos = nullptr;
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
    T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
  Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
  if (Result.isNull())
    return QualType();
}

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

return Result;
5438}

5440template<typename Derived>
5441bool TreeTransform<Derived>::TransformExceptionSpec(
  SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
  SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated)((ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated
) ? static_cast<void> (0) : __assert_fail ("ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 5444, __PRETTY_FUNCTION__));

// Instantiate a dynamic noexcept expression, if any.
if (isComputedNoexcept(ESI.Type)) {
  EnterExpressionEvaluationContext Unevaluated(
      getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
  if (NoexceptExpr.isInvalid())
    return true;

  ExceptionSpecificationType EST = ESI.Type;
  NoexceptExpr =
      getSema().ActOnNoexceptSpec(Loc, NoexceptExpr.get(), EST);
  if (NoexceptExpr.isInvalid())
    return true;

  if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type)
    Changed = true;
  ESI.NoexceptExpr = NoexceptExpr.get();
  ESI.Type = EST;
}

if (ESI.Type != EST_Dynamic)
  return false;

// Instantiate a dynamic exception specification's type.
for (QualType T : ESI.Exceptions) {
  if (const PackExpansionType *PackExpansion =
          T->getAs<PackExpansionType>()) {
    Changed = true;

    // We have a pack expansion. Instantiate it.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
                                            Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? static_cast<void> (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 5479, __PRETTY_FUNCTION__));

    // Determine whether the set of unexpanded parameter packs can and
    // should
    // be expanded.
    bool Expand = false;
    bool RetainExpansion = false;
    Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
    // FIXME: Track the location of the ellipsis (and track source location
    // information for the types in the exception specification in general).
    if (getDerived().TryExpandParameterPacks(
            Loc, SourceRange(), Unexpanded, Expand,
            RetainExpansion, NumExpansions))
      return true;

    if (!Expand) {
      // We can't expand this pack expansion into separate arguments yet;
      // just substitute into the pattern and create a new pack expansion
      // type.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      QualType U = getDerived().TransformType(PackExpansion->getPattern());
      if (U.isNull())
        return true;

      U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
      Exceptions.push_back(U);
      continue;
    }

    // Substitute into the pack expansion pattern for each slice of the
    // pack.
    for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

      QualType U = getDerived().TransformType(PackExpansion->getPattern());
      if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
        return true;

      Exceptions.push_back(U);
    }
  } else {
    QualType U = getDerived().TransformType(T);
    if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
      return true;
    if (T != U)
      Changed = true;

    Exceptions.push_back(U);
  }
}

ESI.Exceptions = Exceptions;
if (ESI.Exceptions.empty())
  ESI.Type = EST_DynamicNone;
return false;
5534}

5536template<typename Derived>
5537QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
                                               TypeLocBuilder &TLB,
                                               FunctionNoProtoTypeLoc TL) {
const FunctionNoProtoType *T = TL.getTypePtr();
QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
if (ResultType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
  Result = getDerived().RebuildFunctionNoProtoType(ResultType);

FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());

return Result;
5556}

5558template<typename Derived> QualType
5559TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
                                               UnresolvedUsingTypeLoc TL) {
const UnresolvedUsingType *T = TL.getTypePtr();
Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
if (!D)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
  Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(), D);
  if (Result.isNull())
    return QualType();
}

// We might get an arbitrary type spec type back.  We should at
// least always get a type spec type, though.
TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5579}

5581template<typename Derived>
5582QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
                                                    TypedefTypeLoc TL) {
const TypedefType *T = TL.getTypePtr();
TypedefNameDecl *Typedef
  = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                             T->getDecl()));
if (!Typedef)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Typedef != T->getDecl()) {
  Result = getDerived().RebuildTypedefType(Typedef);
  if (Result.isNull())
    return QualType();
}

TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5603}

5605template<typename Derived>
5606QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
                                                    TypeOfExprTypeLoc TL) {
// typeof expressions are not potentially evaluated contexts
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
if (E.isInvalid())
  return QualType();

E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
if (E.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    E.get() != TL.getUnderlyingExpr()) {
  Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
  if (Result.isNull())
    return QualType();
}
else E.get();

TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
NewTL.setTypeofLoc(TL.getTypeofLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());

return Result;
5636}

5638template<typename Derived>
5639QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
                                                   TypeOfTypeLoc TL) {
TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
if (!New_Under_TI)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
  Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
  if (Result.isNull())
    return QualType();
}

TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
NewTL.setTypeofLoc(TL.getTypeofLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
NewTL.setUnderlyingTInfo(New_Under_TI);

return Result;
5660}

5662template<typename Derived>
5663QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
                                                     DecltypeTypeLoc TL) {
const DecltypeType *T = TL.getTypePtr();

// decltype expressions are not potentially evaluated contexts
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, nullptr,
    Sema::ExpressionEvaluationContextRecord::EK_Decltype);

ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
if (E.isInvalid())
  return QualType();

E = getSema().ActOnDecltypeExpression(E.get());
if (E.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    E.get() != T->getUnderlyingExpr()) {
  Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
  if (Result.isNull())
    return QualType();
}
else E.get();

DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5693}

5695template<typename Derived>
5696QualType TreeTransform<Derived>::TransformUnaryTransformType(
                                                          TypeLocBuilder &TLB,
                                                   UnaryTransformTypeLoc TL) {
QualType Result = TL.getType();
if (Result->isDependentType()) {
  const UnaryTransformType *T = TL.getTypePtr();
  QualType NewBase =
    getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
  Result = getDerived().RebuildUnaryTransformType(NewBase,
                                                  T->getUTTKind(),
                                                  TL.getKWLoc());
  if (Result.isNull())
    return QualType();
}

UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());
NewTL.setParensRange(TL.getParensRange());
NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
return Result;
5716}

5718template<typename Derived>
5719QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
                                                 AutoTypeLoc TL) {
const AutoType *T = TL.getTypePtr();
QualType OldDeduced = T->getDeducedType();
QualType NewDeduced;
if (!OldDeduced.isNull()) {
  NewDeduced = getDerived().TransformType(OldDeduced);
  if (NewDeduced.isNull())
    return QualType();
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
    T->isDependentType()) {
  Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
  if (Result.isNull())
    return QualType();
}

AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5742}

5744template<typename Derived>
5745QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
  TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
const DeducedTemplateSpecializationType *T = TL.getTypePtr();

CXXScopeSpec SS;
TemplateName TemplateName = getDerived().TransformTemplateName(
    SS, T->getTemplateName(), TL.getTemplateNameLoc());
if (TemplateName.isNull())
  return QualType();

QualType OldDeduced = T->getDeducedType();
QualType NewDeduced;
if (!OldDeduced.isNull()) {
  NewDeduced = getDerived().TransformType(OldDeduced);
  if (NewDeduced.isNull())
    return QualType();
}

QualType Result = getDerived().RebuildDeducedTemplateSpecializationType(
    TemplateName, NewDeduced);
if (Result.isNull())
  return QualType();

DeducedTemplateSpecializationTypeLoc NewTL =
    TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());

return Result;
5773}

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

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Record != T->getDecl()) {
  Result = getDerived().RebuildRecordType(Record);
  if (Result.isNull())
    return QualType();
}

RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5797}

5799template<typename Derived>
5800QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
                                                 EnumTypeLoc TL) {
const EnumType *T = TL.getTypePtr();
EnumDecl *Enum
  = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                      T->getDecl()));
if (!Enum)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Enum != T->getDecl()) {
  Result = getDerived().RebuildEnumType(Enum);
  if (Result.isNull())
    return QualType();
}

EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5821}

5823template<typename Derived>
5824QualType TreeTransform<Derived>::TransformInjectedClassNameType(
                                       TypeLocBuilder &TLB,
                                       InjectedClassNameTypeLoc TL) {
Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
                                     TL.getTypePtr()->getDecl());
if (!D) return QualType();

QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
return T;
5834}

5836template<typename Derived>
5837QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
                                              TypeLocBuilder &TLB,
                                              TemplateTypeParmTypeLoc TL) {
return TransformTypeSpecType(TLB, TL);
5841}

5843template<typename Derived>
5844QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
                                       TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmTypeLoc TL) {
const SubstTemplateTypeParmType *T = TL.getTypePtr();

// Substitute into the replacement type, which itself might involve something
// that needs to be transformed. This only tends to occur with default
// template arguments of template template parameters.
TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
QualType Replacement = getDerived().TransformType(T->getReplacementType());
if (Replacement.isNull())
  return QualType();

// Always canonicalize the replacement type.
Replacement = SemaRef.Context.getCanonicalType(Replacement);
QualType Result
  = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
                                                 Replacement);

// Propagate type-source information.
SubstTemplateTypeParmTypeLoc NewTL
  = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;

5869}

5871template<typename Derived>
5872QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
                                        TypeLocBuilder &TLB,
                                        SubstTemplateTypeParmPackTypeLoc TL) {
return TransformTypeSpecType(TLB, TL);
5876}

5878template<typename Derived>
5879QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                      TypeLocBuilder &TLB,
                                         TemplateSpecializationTypeLoc TL) {
const TemplateSpecializationType *T = TL.getTypePtr();

// The nested-name-specifier never matters in a TemplateSpecializationType,
// because we can't have a dependent nested-name-specifier anyway.
CXXScopeSpec SS;
TemplateName Template
  = getDerived().TransformTemplateName(SS, T->getTemplateName(),
                                       TL.getTemplateNameLoc());
if (Template.isNull())
  return QualType();

return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
5894}

5896template<typename Derived>
5897QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
                                                   AtomicTypeLoc TL) {
QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
if (ValueType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ValueType != TL.getValueLoc().getType()) {
  Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
  if (Result.isNull())
    return QualType();
}

AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());

return Result;
5917}

5919template <typename Derived>
5920QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
                                                 PipeTypeLoc TL) {
QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
if (ValueType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
  const PipeType *PT = Result->getAs<PipeType>();
  bool isReadPipe = PT->isReadOnly();
  Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
  if (Result.isNull())
    return QualType();
}

PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());

return Result;
5939}

/// Simple iterator that traverses the template arguments in a
/// container that provides a \c getArgLoc() member function.
///
/// This iterator is intended to be used with the iterator form of
/// \c TreeTransform<Derived>::TransformTemplateArguments().
template<typename ArgLocContainer>
class TemplateArgumentLocContainerIterator {
  ArgLocContainer *Container;
  unsigned Index;

public:
  typedef TemplateArgumentLoc value_type;
  typedef TemplateArgumentLoc reference;
  typedef int difference_type;
  typedef std::input_iterator_tag iterator_category;

  class pointer {
    TemplateArgumentLoc Arg;

  public:
    explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }

    const TemplateArgumentLoc *operator->() const {
      return &Arg;
    }
  };


  TemplateArgumentLocContainerIterator() {}

  TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
                               unsigned Index)
    : Container(&Container), Index(Index) { }

  TemplateArgumentLocContainerIterator &operator++() {
    ++Index;
    return *this;
  }

  TemplateArgumentLocContainerIterator operator++(int) {
    TemplateArgumentLocContainerIterator Old(*this);
    ++(*this);
    return Old;
  }

  TemplateArgumentLoc operator*() const {
    return Container->getArgLoc(Index);
  }

  pointer operator->() const {
    return pointer(Container->getArgLoc(Index));
  }

  friend bool operator==(const TemplateArgumentLocContainerIterator &X,
                         const TemplateArgumentLocContainerIterator &Y) {
    return X.Container == Y.Container && X.Index == Y.Index;
  }

  friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
                         const TemplateArgumentLocContainerIterator &Y) {
    return !(X == Y);
  }
};


6006template <typename Derived>
6007QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                      TypeLocBuilder &TLB,
                                         TemplateSpecializationTypeLoc TL,
                                                    TemplateName Template) {
TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
  ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

// FIXME: maybe don't rebuild if all the template arguments are the same.

QualType Result =
  getDerived().RebuildTemplateSpecializationType(Template,
                                                 TL.getTemplateNameLoc(),
                                                 NewTemplateArgs);

if (!Result.isNull()) {
  // Specializations of template template parameters are represented as
  // TemplateSpecializationTypes, and substitution of type alias templates
  // within a dependent context can transform them into
  // DependentTemplateSpecializationTypes.
  if (isa<DependentTemplateSpecializationType>(Result)) {
    DependentTemplateSpecializationTypeLoc NewTL
      = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
    NewTL.setElaboratedKeywordLoc(SourceLocation());
    NewTL.setQualifierLoc(NestedNameSpecifierLoc());
    NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
    NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
    NewTL.setLAngleLoc(TL.getLAngleLoc());
    NewTL.setRAngleLoc(TL.getRAngleLoc());
    for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
      NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
    return Result;
  }

  TemplateSpecializationTypeLoc NewTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
}

return Result;
6058}

6060template <typename Derived>
6061QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
                                   TypeLocBuilder &TLB,
                                   DependentTemplateSpecializationTypeLoc TL,
                                   TemplateName Template,
                                   CXXScopeSpec &SS) {
TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
typedef TemplateArgumentLocContainerIterator<
          DependentTemplateSpecializationTypeLoc> ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

// FIXME: maybe don't rebuild if all the template arguments are the same.

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType Result
    = getSema().Context.getDependentTemplateSpecializationType(
                                              TL.getTypePtr()->getKeyword(),
                                                       DTN->getQualifier(),
                                                       DTN->getIdentifier(),
                                                             NewTemplateArgs);

  DependentTemplateSpecializationTypeLoc NewTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
  return Result;
}

QualType Result
  = getDerived().RebuildTemplateSpecializationType(Template,
                                                   TL.getTemplateNameLoc(),
                                                   NewTemplateArgs);

if (!Result.isNull()) {
  /// FIXME: Wrap this in an elaborated-type-specifier?
  TemplateSpecializationTypeLoc NewTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
}

return Result;
6117}

6119template<typename Derived>
6120QualType
6121TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
                                              ElaboratedTypeLoc TL) {
const ElaboratedType *T = TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc;
// NOTE: the qualifier in an ElaboratedType is optional.
if (TL.getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
  if (!QualifierLoc)
    return QualType();
}

QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
if (NamedT.isNull())
  return QualType();

// C++0x [dcl.type.elab]p2:
//   If the identifier resolves to a typedef-name or the simple-template-id
//   resolves to an alias template specialization, the
//   elaborated-type-specifier is ill-formed.
if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) {
  if (const TemplateSpecializationType *TST =
        NamedT->getAs<TemplateSpecializationType>()) {
    TemplateName Template = TST->getTemplateName();
    if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
            Template.getAsTemplateDecl())) {
      SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(),
                   diag::err_tag_reference_non_tag)
          << TAT << Sema::NTK_TypeAliasTemplate
          << ElaboratedType::getTagTypeKindForKeyword(T->getKeyword());
      SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
    }
  }
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    QualifierLoc != TL.getQualifierLoc() ||
    NamedT != T->getNamedType()) {
  Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(),
                                              T->getKeyword(),
                                              QualifierLoc, NamedT);
  if (Result.isNull())
    return QualType();
}

ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
NewTL.setQualifierLoc(QualifierLoc);
return Result;
6172}

6174template<typename Derived>
6175QualType TreeTransform<Derived>::TransformAttributedType(
                                              TypeLocBuilder &TLB,
                                              AttributedTypeLoc TL) {
const AttributedType *oldType = TL.getTypePtr();
QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
if (modifiedType.isNull())
  return QualType();

// oldAttr can be null if we started with a QualType rather than a TypeLoc.
const Attr *oldAttr = TL.getAttr();
const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) : nullptr;
if (oldAttr && !newAttr)
  return QualType();

QualType result = TL.getType();

// FIXME: dependent operand expressions?
if (getDerived().AlwaysRebuild() ||
    modifiedType != oldType->getModifiedType()) {
  // TODO: this is really lame; we should really be rebuilding the
  // equivalent type from first principles.
  QualType equivalentType
    = getDerived().TransformType(oldType->getEquivalentType());
  if (equivalentType.isNull())
    return QualType();

  // Check whether we can add nullability; it is only represented as
  // type sugar, and therefore cannot be diagnosed in any other way.
  if (auto nullability = oldType->getImmediateNullability()) {
    if (!modifiedType->canHaveNullability()) {
      SemaRef.Diag(TL.getAttr()->getLocation(),
                   diag::err_nullability_nonpointer)
          << DiagNullabilityKind(*nullability, false) << modifiedType;
      return QualType();
    }
  }

  result = SemaRef.Context.getAttributedType(TL.getAttrKind(),
                                             modifiedType,
                                             equivalentType);
}

AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
newTL.setAttr(newAttr);
return result;
6220}

6222template<typename Derived>
6223QualType
6224TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
                                         ParenTypeLoc TL) {
QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
if (Inner.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Inner != TL.getInnerLoc().getType()) {
  Result = getDerived().RebuildParenType(Inner);
  if (Result.isNull())
    return QualType();
}

ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
return Result;
6242}

6244template <typename Derived>
6245QualType
6246TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
                                                  MacroQualifiedTypeLoc TL) {
QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
if (Inner.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
  Result =
      getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
  if (Result.isNull())
    return QualType();
}

MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result);
NewTL.setExpansionLoc(TL.getExpansionLoc());
return Result;
6263}

6265template<typename Derived>
6266QualType TreeTransform<Derived>::TransformDependentNameType(
  TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
return TransformDependentNameType(TLB, TL, false);
6269}

6271template<typename Derived>
6272QualType TreeTransform<Derived>::TransformDependentNameType(
  TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext) {
const DependentNameType *T = TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
if (!QualifierLoc)
  return QualType();

QualType Result
  = getDerived().RebuildDependentNameType(T->getKeyword(),
                                          TL.getElaboratedKeywordLoc(),
                                          QualifierLoc,
                                          T->getIdentifier(),
                                          TL.getNameLoc(),
                                          DeducedTSTContext);
if (Result.isNull())
  return QualType();

if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
  QualType NamedT = ElabT->getNamedType();
  TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());

  ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
} else {
  DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
  NewTL.setNameLoc(TL.getNameLoc());
}
return Result;
6305}

6307template<typename Derived>
6308QualType TreeTransform<Derived>::
        TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                               DependentTemplateSpecializationTypeLoc TL) {
NestedNameSpecifierLoc QualifierLoc;
if (TL.getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
  if (!QualifierLoc)
    return QualType();
}

return getDerived()
         .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
6321}

6323template<typename Derived>
6324QualType TreeTransform<Derived>::
6325TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                                 DependentTemplateSpecializationTypeLoc TL,
                                     NestedNameSpecifierLoc QualifierLoc) {
const DependentTemplateSpecializationType *T = TL.getTypePtr();

TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());

typedef TemplateArgumentLocContainerIterator<
DependentTemplateSpecializationTypeLoc> ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
    T->getKeyword(), QualifierLoc, TL.getTemplateKeywordLoc(),
    T->getIdentifier(), TL.getTemplateNameLoc(), NewTemplateArgs,
    /*AllowInjectedClassName*/ false);
if (Result.isNull())
  return QualType();

if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
  QualType NamedT = ElabT->getNamedType();

  // Copy information relevant to the template specialization.
  TemplateSpecializationTypeLoc NamedTL
    = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
  NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NamedTL.setLAngleLoc(TL.getLAngleLoc());
  NamedTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());

  // Copy information relevant to the elaborated type.
  ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
} else if (isa<DependentTemplateSpecializationType>(Result)) {
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
  SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  SpecTL.setQualifierLoc(QualifierLoc);
  SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  SpecTL.setLAngleLoc(TL.getLAngleLoc());
  SpecTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
} else {
  TemplateSpecializationTypeLoc SpecTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  SpecTL.setLAngleLoc(TL.getLAngleLoc());
  SpecTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
}
return Result;
6387}

6389template<typename Derived>
6390QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
                                                    PackExpansionTypeLoc TL) {
QualType Pattern
  = getDerived().TransformType(TLB, TL.getPatternLoc());
if (Pattern.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Pattern != TL.getPatternLoc().getType()) {
  Result = getDerived().RebuildPackExpansionType(Pattern,
                                         TL.getPatternLoc().getSourceRange(),
                                                 TL.getEllipsisLoc(),
                                         TL.getTypePtr()->getNumExpansions());
  if (Result.isNull())
    return QualType();
}

PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
NewT.setEllipsisLoc(TL.getEllipsisLoc());
return Result;
6411}

6413template<typename Derived>
6414QualType
6415TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
                                                 ObjCInterfaceTypeLoc TL) {
// ObjCInterfaceType is never dependent.
TLB.pushFullCopy(TL);
return TL.getType();
6420}

6422template<typename Derived>
6423QualType
6424TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
                                                 ObjCTypeParamTypeLoc TL) {
const ObjCTypeParamType *T = TL.getTypePtr();
ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
    getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
if (!OTP)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    OTP != T->getDecl()) {
  Result = getDerived().RebuildObjCTypeParamType(OTP,
               TL.getProtocolLAngleLoc(),
               llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
                                  TL.getNumProtocols()),
               TL.getProtocolLocs(),
               TL.getProtocolRAngleLoc());
  if (Result.isNull())
    return QualType();
}

ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
if (TL.getNumProtocols()) {
  NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
  for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
    NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
  NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
}
return Result;
6453}

6455template<typename Derived>
6456QualType
6457TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
                                              ObjCObjectTypeLoc TL) {
// Transform base type.
QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
if (BaseType.isNull())
  return QualType();

bool AnyChanged = BaseType != TL.getBaseLoc().getType();

// Transform type arguments.
SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
  TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
  TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
  QualType TypeArg = TypeArgInfo->getType();
  if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
    AnyChanged = true;

    // We have a pack expansion. Instantiate it.
    const auto *PackExpansion = PackExpansionLoc.getType()
                                  ->castAs<PackExpansionType>();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
                                            Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? static_cast<void> (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 6481, __PRETTY_FUNCTION__));

    // Determine whether the set of unexpanded parameter packs can
    // and should be expanded.
    TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
    bool Expand = false;
    bool RetainExpansion = false;
    Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
    if (getDerived().TryExpandParameterPacks(
          PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
          Unexpanded, Expand, RetainExpansion, NumExpansions))
      return QualType();

    if (!Expand) {
      // We can't expand this pack expansion into separate arguments yet;
      // just substitute into the pattern and create a new pack expansion
      // type.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

      TypeLocBuilder TypeArgBuilder;
      TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
      QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
                                                           PatternLoc);
      if (NewPatternType.isNull())
        return QualType();

      QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
                                    NewPatternType, NumExpansions);
      auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
      NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
      NewTypeArgInfos.push_back(
        TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
      continue;
    }

    // Substitute into the pack expansion pattern for each slice of the
    // pack.
    for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

      TypeLocBuilder TypeArgBuilder;
      TypeArgBuilder.reserve(PatternLoc.getFullDataSize());

      QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
                                                       PatternLoc);
      if (NewTypeArg.isNull())
        return QualType();

      NewTypeArgInfos.push_back(
        TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
    }

    continue;
  }

  TypeLocBuilder TypeArgBuilder;
  TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
  QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
  if (NewTypeArg.isNull())
    return QualType();

  // If nothing changed, just keep the old TypeSourceInfo.
  if (NewTypeArg == TypeArg) {
    NewTypeArgInfos.push_back(TypeArgInfo);
    continue;
  }

  NewTypeArgInfos.push_back(
    TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
  AnyChanged = true;
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || AnyChanged) {
  // Rebuild the type.
  Result = getDerived().RebuildObjCObjectType(
      BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
      TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
      llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
      TL.getProtocolLocs(), TL.getProtocolRAngleLoc());

  if (Result.isNull())
    return QualType();
}

ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
NewT.setHasBaseTypeAsWritten(true);
NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
  NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
  NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
return Result;
6577}

6579template<typename Derived>
6580QualType
6581TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
                                             ObjCObjectPointerTypeLoc TL) {
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
                                                     TL.getStarLoc());
  if (Result.isNull())
    return QualType();
}

ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
NewT.setStarLoc(TL.getStarLoc());
return Result;
6599}

6601//===----------------------------------------------------------------------===//
6602// Statement transformation
6603//===----------------------------------------------------------------------===//
6604template<typename Derived>
6605StmtResult
6606TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
return S;
6608}

6610template<typename Derived>
6611StmtResult
6612TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
return getDerived().TransformCompoundStmt(S, false);
6614}

6616template<typename Derived>
6617StmtResult
6618TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
                                            bool IsStmtExpr) {
Sema::CompoundScopeRAII CompoundScope(getSema());

const Stmt *ExprResult = S->getStmtExprResult();
bool SubStmtInvalid = false;
bool SubStmtChanged = false;
SmallVector<Stmt*, 8> Statements;
for (auto *B : S->body()) {
  StmtResult Result = getDerived().TransformStmt(
      B, IsStmtExpr && B == ExprResult ? SDK_StmtExprResult : SDK_Discarded);

  if (Result.isInvalid()) {
    // Immediately fail if this was a DeclStmt, since it's very
    // likely that this will cause problems for future statements.
    if (isa<DeclStmt>(B))
      return StmtError();

    // Otherwise, just keep processing substatements and fail later.
    SubStmtInvalid = true;
    continue;
  }

  SubStmtChanged = SubStmtChanged || Result.get() != B;
  Statements.push_back(Result.getAs<Stmt>());
}

if (SubStmtInvalid)
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    !SubStmtChanged)
  return S;

return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
                                        Statements,
                                        S->getRBracLoc(),
                                        IsStmtExpr);
6656}

6658template<typename Derived>
6659StmtResult
6660TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
ExprResult LHS, RHS;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  // Transform the left-hand case value.
  LHS = getDerived().TransformExpr(S->getLHS());
  LHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), LHS);
  if (LHS.isInvalid())
    return StmtError();

  // Transform the right-hand case value (for the GNU case-range extension).
  RHS = getDerived().TransformExpr(S->getRHS());
  RHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), RHS);
  if (RHS.isInvalid())
    return StmtError();
}

// Build the case statement.
// Case statements are always rebuilt so that they will attached to their
// transformed switch statement.
StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
                                                     LHS.get(),
                                                     S->getEllipsisLoc(),
                                                     RHS.get(),
                                                     S->getColonLoc());
if (Case.isInvalid())
  return StmtError();

// Transform the statement following the case
StmtResult SubStmt =
    getDerived().TransformStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// Attach the body to the case statement
return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
6698}

6700template <typename Derived>
6701StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
// Transform the statement following the default case
StmtResult SubStmt =
    getDerived().TransformStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// Default statements are always rebuilt
return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
                                       SubStmt.get());
6711}

6713template<typename Derived>
6714StmtResult
6715TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
if (SubStmt.isInvalid())
  return StmtError();

Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
                                      S->getDecl());
if (!LD)
  return StmtError();

// If we're transforming "in-place" (we're not creating new local
// declarations), assume we're replacing the old label statement
// and clear out the reference to it.
if (LD == S->getDecl())
  S->getDecl()->setStmt(nullptr);

// FIXME: Pass the real colon location in.
return getDerived().RebuildLabelStmt(S->getIdentLoc(),
                                     cast<LabelDecl>(LD), SourceLocation(),
                                     SubStmt.get());
6735}

6737template <typename Derived>
6738const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
if (!R)
  return R;

switch (R->getKind()) {
6743// Transform attributes with a pragma spelling by calling TransformXXXAttr.
6744#define ATTR(X)
6745#define PRAGMA_SPELLING_ATTR(X)                                                \
case attr::X:                                                                \
  return getDerived().Transform##X##Attr(cast<X##Attr>(R));
6748#include "clang/Basic/AttrList.inc"
default:
  return R;
}
6752}

6754template <typename Derived>
6755StmtResult
6756TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S,
                                              StmtDiscardKind SDK) {
bool AttrsChanged = false;
SmallVector<const Attr *, 1> Attrs;

// Visit attributes and keep track if any are transformed.
for (const auto *I : S->getAttrs()) {
  const Attr *R = getDerived().TransformAttr(I);
  AttrsChanged |= (I != R);
  Attrs.push_back(R);
}

StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
if (SubStmt.isInvalid())
  return StmtError();

if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
  return S;

return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
                                          SubStmt.get());
6777}

6779template<typename Derived>
6780StmtResult
6781TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getIfLoc(), S->getConditionVariable(), S->getCond(),
    S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
                     : Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// If this is a constexpr if, determine which arm we should instantiate.
llvm::Optional<bool> ConstexprConditionValue;
if (S->isConstexpr())
  ConstexprConditionValue = Cond.getKnownValue();

// Transform the "then" branch.
StmtResult Then;
if (!ConstexprConditionValue || *ConstexprConditionValue) {
  Then = getDerived().TransformStmt(S->getThen());
  if (Then.isInvalid())
    return StmtError();
} else {
  Then = new (getSema().Context) NullStmt(S->getThen()->getBeginLoc());
}

// Transform the "else" branch.
StmtResult Else;
if (!ConstexprConditionValue || !*ConstexprConditionValue) {
  Else = getDerived().TransformStmt(S->getElse());
  if (Else.isInvalid())
    return StmtError();
}

if (!getDerived().AlwaysRebuild() &&
    Init.get() == S->getInit() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Then.get() == S->getThen() &&
    Else.get() == S->getElse())
  return S;

return getDerived().RebuildIfStmt(S->getIfLoc(), S->isConstexpr(), Cond,
                                  Init.get(), Then.get(), S->getElseLoc(),
                                  Else.get());
6828}

6830template<typename Derived>
6831StmtResult
6832TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// Transform the condition.
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Switch);
if (Cond.isInvalid())
  return StmtError();

// Rebuild the switch statement.
StmtResult Switch
  = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Init.get(), Cond);
if (Switch.isInvalid())
  return StmtError();

// Transform the body of the switch statement.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Complete the switch statement.
return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
                                          Body.get());
6859}

6861template<typename Derived>
6862StmtResult
6863TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Body.get() == S->getBody())
  return Owned(S);

return getDerived().RebuildWhileStmt(S->getWhileLoc(), Cond, Body.get());
6882}

6884template<typename Derived>
6885StmtResult
6886TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Transform the condition
ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == S->getCond() &&
    Body.get() == S->getBody())
  return S;

return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
                                  /*FIXME:*/S->getWhileLoc(), Cond.get(),
                                  S->getRParenLoc());
6905}

6907template<typename Derived>
6908StmtResult
6909TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
if (getSema().getLangOpts().OpenMP)
  getSema().startOpenMPLoop();

// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// In OpenMP loop region loop control variable must be captured and be
// private. Perform analysis of first part (if any).
if (getSema().getLangOpts().OpenMP && Init.isUsable())
  getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());

// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getForLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// Transform the increment
ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
  return StmtError();

Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
if (S->getInc() && !FullInc.get())
  return StmtError();

// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Init.get() == S->getInit() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Inc.get() == S->getInc() &&
    Body.get() == S->getBody())
  return S;

return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
                                   Init.get(), Cond, FullInc,
                                   S->getRParenLoc(), Body.get());
6954}

6956template<typename Derived>
6957StmtResult
6958TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
                                      S->getLabel());
if (!LD)
  return StmtError();

// Goto statements must always be rebuilt, to resolve the label.
return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
                                    cast<LabelDecl>(LD));
6967}

6969template<typename Derived>
6970StmtResult
6971TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
ExprResult Target = getDerived().TransformExpr(S->getTarget());
if (Target.isInvalid())
  return StmtError();
Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());

if (!getDerived().AlwaysRebuild() &&
    Target.get() == S->getTarget())
  return S;

return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
                                            Target.get());
6983}

6985template<typename Derived>
6986StmtResult
6987TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
return S;
6989}

6991template<typename Derived>
6992StmtResult
6993TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
return S;
6995}

6997template<typename Derived>
6998StmtResult
6999TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return StmtError();

// FIXME: We always rebuild the return statement because there is no way
// to tell whether the return type of the function has changed.
return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
7008}

7010template<typename Derived>
7011StmtResult
7012TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
bool DeclChanged = false;
SmallVector<Decl *, 4> Decls;
for (auto *D : S->decls()) {
  Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
  if (!Transformed)
    return StmtError();

  if (Transformed != D)
    DeclChanged = true;

  Decls.push_back(Transformed);
}

if (!getDerived().AlwaysRebuild() && !DeclChanged)
  return S;

return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
7030}

7032template<typename Derived>
7033StmtResult
7034TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {

SmallVector<Expr*, 8> Constraints;
SmallVector<Expr*, 8> Exprs;
SmallVector<IdentifierInfo *, 4> Names;

ExprResult AsmString;
SmallVector<Expr*, 8> Clobbers;

bool ExprsChanged = false;

// Go through the outputs.
for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
  Names.push_back(S->getOutputIdentifier(I));

  // No need to transform the constraint literal.
  Constraints.push_back(S->getOutputConstraintLiteral(I));

  // Transform the output expr.
  Expr *OutputExpr = S->getOutputExpr(I);
  ExprResult Result = getDerived().TransformExpr(OutputExpr);
  if (Result.isInvalid())
    return StmtError();

  ExprsChanged |= Result.get() != OutputExpr;

  Exprs.push_back(Result.get());
}

// Go through the inputs.
for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
  Names.push_back(S->getInputIdentifier(I));

  // No need to transform the constraint literal.
  Constraints.push_back(S->getInputConstraintLiteral(I));

  // Transform the input expr.
  Expr *InputExpr = S->getInputExpr(I);
  ExprResult Result = getDerived().TransformExpr(InputExpr);
  if (Result.isInvalid())
    return StmtError();

  ExprsChanged |= Result.get() != InputExpr;

  Exprs.push_back(Result.get());
}

// Go through the Labels.
for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
  Names.push_back(S->getLabelIdentifier(I));

  ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I));
  if (Result.isInvalid())
    return StmtError();
  ExprsChanged |= Result.get() != S->getLabelExpr(I);
  Exprs.push_back(Result.get());
}
if (!getDerived().AlwaysRebuild() && !ExprsChanged)
  return S;

// Go through the clobbers.
for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
  Clobbers.push_back(S->getClobberStringLiteral(I));

// No need to transform the asm string literal.
AsmString = S->getAsmString();
return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
                                      S->isVolatile(), S->getNumOutputs(),
                                      S->getNumInputs(), Names.data(),
                                      Constraints, Exprs, AsmString.get(),
                                      Clobbers, S->getNumLabels(),
                                      S->getRParenLoc());
7106}

7108template<typename Derived>
7109StmtResult
7110TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
ArrayRef<Token> AsmToks =
  llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());

bool HadError = false, HadChange = false;

ArrayRef<Expr*> SrcExprs = S->getAllExprs();
SmallVector<Expr*, 8> TransformedExprs;
TransformedExprs.reserve(SrcExprs.size());
for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
  ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
  if (!Result.isUsable()) {
    HadError = true;
  } else {
    HadChange |= (Result.get() != SrcExprs[i]);
    TransformedExprs.push_back(Result.get());
  }
}

if (HadError) return StmtError();
if (!HadChange && !getDerived().AlwaysRebuild())
  return Owned(S);

return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
                                     AsmToks, S->getAsmString(),
                                     S->getNumOutputs(), S->getNumInputs(),
                                     S->getAllConstraints(), S->getClobbers(),
                                     TransformedExprs, S->getEndLoc());
7138}

7140// C++ Coroutines TS

7142template<typename Derived>
7143StmtResult
7144TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
auto *ScopeInfo = SemaRef.getCurFunction();
auto *FD = cast<FunctionDecl>(SemaRef.CurContext);
assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&((FD && ScopeInfo && !ScopeInfo->CoroutinePromise
 && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo
->CoroutineSuspends.first == nullptr && ScopeInfo->
CoroutineSuspends.second == nullptr && "expected clean scope info"
) ? static_cast<void> (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7151, __PRETTY_FUNCTION__))
       ScopeInfo->NeedsCoroutineSuspends &&((FD && ScopeInfo && !ScopeInfo->CoroutinePromise
 && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo
->CoroutineSuspends.first == nullptr && ScopeInfo->
CoroutineSuspends.second == nullptr && "expected clean scope info"
) ? static_cast<void> (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7151, __PRETTY_FUNCTION__))
       ScopeInfo->CoroutineSuspends.first == nullptr &&((FD && ScopeInfo && !ScopeInfo->CoroutinePromise
 && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo
->CoroutineSuspends.first == nullptr && ScopeInfo->
CoroutineSuspends.second == nullptr && "expected clean scope info"
) ? static_cast<void> (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7151, __PRETTY_FUNCTION__))
       ScopeInfo->CoroutineSuspends.second == nullptr &&((FD && ScopeInfo && !ScopeInfo->CoroutinePromise
 && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo
->CoroutineSuspends.first == nullptr && ScopeInfo->
CoroutineSuspends.second == nullptr && "expected clean scope info"
) ? static_cast<void> (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7151, __PRETTY_FUNCTION__))
       "expected clean scope info")((FD && ScopeInfo && !ScopeInfo->CoroutinePromise
 && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo
->CoroutineSuspends.first == nullptr && ScopeInfo->
CoroutineSuspends.second == nullptr && "expected clean scope info"
) ? static_cast<void> (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7151, __PRETTY_FUNCTION__));

// Set that we have (possibly-invalid) suspend points before we do anything
// that may fail.
ScopeInfo->setNeedsCoroutineSuspends(false);

// The new CoroutinePromise object needs to be built and put into the current
// FunctionScopeInfo before any transformations or rebuilding occurs.
if (!SemaRef.buildCoroutineParameterMoves(FD->getLocation()))
  return StmtError();
auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation());
if (!Promise)
  return StmtError();
getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
ScopeInfo->CoroutinePromise = Promise;

// Transform the implicit coroutine statements we built during the initial
// parse.
StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
if (InitSuspend.isInvalid())
  return StmtError();
StmtResult FinalSuspend =
    getDerived().TransformStmt(S->getFinalSuspendStmt());
if (FinalSuspend.isInvalid())
  return StmtError();
ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()))((isa<Expr>(InitSuspend.get()) && isa<Expr>
(FinalSuspend.get())) ? static_cast<void> (0) : __assert_fail
 ("isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get())"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7177, __PRETTY_FUNCTION__));

StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
if (BodyRes.isInvalid())
  return StmtError();

CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
if (Builder.isInvalid())
  return StmtError();

Expr *ReturnObject = S->getReturnValueInit();
assert(ReturnObject && "the return object is expected to be valid")((ReturnObject && "the return object is expected to be valid"
) ? static_cast<void> (0) : __assert_fail ("ReturnObject && \"the return object is expected to be valid\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7188, __PRETTY_FUNCTION__));
ExprResult Res = getDerived().TransformInitializer(ReturnObject,
                                                   /*NoCopyInit*/ false);
if (Res.isInvalid())
  return StmtError();
Builder.ReturnValue = Res.get();

if (S->hasDependentPromiseType()) {
  // PR41909: We may find a generic coroutine lambda definition within a
  // template function that is being instantiated. In this case, the lambda
  // will have a dependent promise type, until it is used in an expression
  // that creates an instantiation with a non-dependent promise type. We
  // should not assert or build coroutine dependent statements for such a
  // generic lambda.
  auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD);
  if (!MD || !MD->getParent()->isGenericLambda()) {
    assert(!Promise->getType()->isDependentType() &&((!Promise->getType()->isDependentType() && "the promise type must no longer be dependent"
) ? static_cast<void> (0) : __assert_fail ("!Promise->getType()->isDependentType() && \"the promise type must no longer be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7205, __PRETTY_FUNCTION__))
           "the promise type must no longer be dependent")((!Promise->getType()->isDependentType() && "the promise type must no longer be dependent"
) ? static_cast<void> (0) : __assert_fail ("!Promise->getType()->isDependentType() && \"the promise type must no longer be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7205, __PRETTY_FUNCTION__));
    assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&((!S->getFallthroughHandler() && !S->getExceptionHandler
() && !S->getReturnStmtOnAllocFailure() &&
 !S->getDeallocate() && "these nodes should not have been built yet"
) ? static_cast<void> (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7208, __PRETTY_FUNCTION__))
           !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&((!S->getFallthroughHandler() && !S->getExceptionHandler
() && !S->getReturnStmtOnAllocFailure() &&
 !S->getDeallocate() && "these nodes should not have been built yet"
) ? static_cast<void> (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7208, __PRETTY_FUNCTION__))
           "these nodes should not have been built yet")((!S->getFallthroughHandler() && !S->getExceptionHandler
() && !S->getReturnStmtOnAllocFailure() &&
 !S->getDeallocate() && "these nodes should not have been built yet"
) ? static_cast<void> (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7208, __PRETTY_FUNCTION__));
    if (!Builder.buildDependentStatements())
      return StmtError();
  }
} else {
  if (auto *OnFallthrough = S->getFallthroughHandler()) {
    StmtResult Res = getDerived().TransformStmt(OnFallthrough);
    if (Res.isInvalid())
      return StmtError();
    Builder.OnFallthrough = Res.get();
  }

  if (auto *OnException = S->getExceptionHandler()) {
    StmtResult Res = getDerived().TransformStmt(OnException);
    if (Res.isInvalid())
      return StmtError();
    Builder.OnException = Res.get();
  }

  if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
    StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
    if (Res.isInvalid())
      return StmtError();
    Builder.ReturnStmtOnAllocFailure = Res.get();
  }

  // Transform any additional statements we may have already built
  assert(S->getAllocate() && S->getDeallocate() &&((S->getAllocate() && S->getDeallocate() &&
 "allocation and deallocation calls must already be built") ?
 static_cast<void> (0) : __assert_fail ("S->getAllocate() && S->getDeallocate() && \"allocation and deallocation calls must already be built\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7236, __PRETTY_FUNCTION__))
         "allocation and deallocation calls must already be built")((S->getAllocate() && S->getDeallocate() &&
 "allocation and deallocation calls must already be built") ?
 static_cast<void> (0) : __assert_fail ("S->getAllocate() && S->getDeallocate() && \"allocation and deallocation calls must already be built\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7236, __PRETTY_FUNCTION__));
  ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
  if (AllocRes.isInvalid())
    return StmtError();
  Builder.Allocate = AllocRes.get();

  ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
  if (DeallocRes.isInvalid())
    return StmtError();
  Builder.Deallocate = DeallocRes.get();

  assert(S->getResultDecl() && "ResultDecl must already be built")((S->getResultDecl() && "ResultDecl must already be built"
) ? static_cast<void> (0) : __assert_fail ("S->getResultDecl() && \"ResultDecl must already be built\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 7247, __PRETTY_FUNCTION__));
  StmtResult ResultDecl = getDerived().TransformStmt(S->getResultDecl());
  if (ResultDecl.isInvalid())
    return StmtError();
  Builder.ResultDecl = ResultDecl.get();

  if (auto *ReturnStmt = S->getReturnStmt()) {
    StmtResult Res = getDerived().TransformStmt(ReturnStmt);
    if (Res.isInvalid())
      return StmtError();
    Builder.ReturnStmt = Res.get();
  }
}

return getDerived().RebuildCoroutineBodyStmt(Builder);
7262}

7264template<typename Derived>
7265StmtResult
7266TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return StmtError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
                                        S->isImplicit());
7276}

7278template<typename Derived>
7279ExprResult
7280TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return ExprError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get(),
                                       E->isImplicit());
7290}

7292template <typename Derived>
7293ExprResult
7294TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) {
ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/ false);
if (OperandResult.isInvalid())
  return ExprError();

ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
        E->getOperatorCoawaitLookup());

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

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildDependentCoawaitExpr(
    E->getKeywordLoc(), OperandResult.get(),
    cast<UnresolvedLookupExpr>(LookupResult.get()));
7311}

7313template<typename Derived>
7314ExprResult
7315TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return ExprError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
7324}

7326// Objective-C Statements.

7328template<typename Derived>
7329StmtResult
7330TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
// Transform the body of the @try.
StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
if (TryBody.isInvalid())
  return StmtError();

// Transform the @catch statements (if present).
bool AnyCatchChanged = false;
SmallVector<Stmt*, 8> CatchStmts;
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
  StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
  if (Catch.isInvalid())
    return StmtError();
  if (Catch.get() != S->getCatchStmt(I))
    AnyCatchChanged = true;
  CatchStmts.push_back(Catch.get());
}

// Transform the @finally statement (if present).
StmtResult Finally;
if (S->getFinallyStmt()) {
  Finally = getDerived().TransformStmt(S->getFinallyStmt());
  if (Finally.isInvalid())
    return StmtError();
}

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    TryBody.get() == S->getTryBody() &&
    !AnyCatchChanged &&
    Finally.get() == S->getFinallyStmt())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
                                         CatchStmts, Finally.get());
7366}

7368template<typename Derived>
7369StmtResult
7370TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
// Transform the @catch parameter, if there is one.
VarDecl *Var = nullptr;
if (VarDecl *FromVar = S->getCatchParamDecl()) {
  TypeSourceInfo *TSInfo = nullptr;
  if (FromVar->getTypeSourceInfo()) {
    TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
    if (!TSInfo)
      return StmtError();
  }

  QualType T;
  if (TSInfo)
    T = TSInfo->getType();
  else {
    T = getDerived().TransformType(FromVar->getType());
    if (T.isNull())
      return StmtError();
  }

  Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
  if (!Var)
    return StmtError();
}

StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
if (Body.isInvalid())
  return StmtError();

return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
                                           S->getRParenLoc(),
                                           Var, Body.get());
7402}

7404template<typename Derived>
7405StmtResult
7406TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Body.get() == S->getFinallyBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
                                             Body.get());
7420}

7422template<typename Derived>
7423StmtResult
7424TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
ExprResult Operand;
if (S->getThrowExpr()) {
  Operand = getDerived().TransformExpr(S->getThrowExpr());
  if (Operand.isInvalid())
    return StmtError();
}

if (!getDerived().AlwaysRebuild() &&
    Operand.get() == S->getThrowExpr())
  return S;

return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
7437}

7439template<typename Derived>
7440StmtResult
7441TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
                                                ObjCAtSynchronizedStmt *S) {
// Transform the object we are locking.
ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
if (Object.isInvalid())
  return StmtError();
Object =
  getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
                                                Object.get());
if (Object.isInvalid())
  return StmtError();

// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
if (Body.isInvalid())
  return StmtError();

// If nothing change, just retain the current statement.
if (!getDerived().AlwaysRebuild() &&
    Object.get() == S->getSynchExpr() &&
    Body.get() == S->getSynchBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
                                                  Object.get(), Body.get());
7467}

7469template<typename Derived>
7470StmtResult
7471TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
                                            ObjCAutoreleasePoolStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Body.get() == S->getSubStmt())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAutoreleasePoolStmt(
                      S->getAtLoc(), Body.get());
7486}

7488template<typename Derived>
7489StmtResult
7490TreeTransform<Derived>::TransformObjCForCollectionStmt(
                                                ObjCForCollectionStmt *S) {
// Transform the element statement.
StmtResult Element =
    getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
if (Element.isInvalid())
  return StmtError();

// Transform the collection expression.
ExprResult Collection = getDerived().TransformExpr(S->getCollection());
if (Collection.isInvalid())
  return StmtError();

// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Element.get() == S->getElement() &&
    Collection.get() == S->getCollection() &&
    Body.get() == S->getBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
                                                 Element.get(),
                                                 Collection.get(),
                                                 S->getRParenLoc(),
                                                 Body.get());
7521}

7523template <typename Derived>
7524StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
// Transform the exception declaration, if any.
VarDecl *Var = nullptr;
if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
  TypeSourceInfo *T =
      getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
  if (!T)
    return StmtError();

  Var = getDerived().RebuildExceptionDecl(
      ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
      ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
  if (!Var || Var->isInvalidDecl())
    return StmtError();
}

// Transform the actual exception handler.
StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
if (Handler.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() && !Var &&
    Handler.get() == S->getHandlerBlock())
  return S;

return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
7550}

7552template <typename Derived>
7553StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
// Transform the try block itself.
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
  return StmtError();

// Transform the handlers.
bool HandlerChanged = false;
SmallVector<Stmt *, 8> Handlers;
for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
  StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
  if (Handler.isInvalid())
    return StmtError();

  HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
  Handlers.push_back(Handler.getAs<Stmt>());
}

if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
    !HandlerChanged)
  return S;

return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
                                      Handlers);
7577}

7579template<typename Derived>
7580StmtResult
7581TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
StmtResult Init =
    S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
if (Init.isInvalid())
  return StmtError();

StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
if (Range.isInvalid())
  return StmtError();

StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
if (Begin.isInvalid())
  return StmtError();
StmtResult End = getDerived().TransformStmt(S->getEndStmt());
if (End.isInvalid())
  return StmtError();

ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
  return StmtError();
if (Cond.get())
  Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
if (Cond.isInvalid())
  return StmtError();
if (Cond.get())
  Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());

ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
  return StmtError();
if (Inc.get())
  Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());

StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
if (LoopVar.isInvalid())
  return StmtError();

StmtResult NewStmt = S;
if (getDerived().AlwaysRebuild() ||
    Init.get() != S->getInit() ||
    Range.get() != S->getRangeStmt() ||
    Begin.get() != S->getBeginStmt() ||
    End.get() != S->getEndStmt() ||
    Cond.get() != S->getCond() ||
    Inc.get() != S->getInc() ||
    LoopVar.get() != S->getLoopVarStmt()) {
  NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
                                                S->getCoawaitLoc(), Init.get(),
                                                S->getColonLoc(), Range.get(),
                                                Begin.get(), End.get(),
                                                Cond.get(),
                                                Inc.get(), LoopVar.get(),
                                                S->getRParenLoc());
  if (NewStmt.isInvalid())
    return StmtError();
}

StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Body has changed but we didn't rebuild the for-range statement. Rebuild
// it now so we have a new statement to attach the body to.
if (Body.get() != S->getBody() && NewStmt.get() == S) {
  NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
                                                S->getCoawaitLoc(), Init.get(),
                                                S->getColonLoc(), Range.get(),
                                                Begin.get(), End.get(),
                                                Cond.get(),
                                                Inc.get(), LoopVar.get(),
                                                S->getRParenLoc());
  if (NewStmt.isInvalid())
    return StmtError();
}

if (NewStmt.get() == S)
  return S;

return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
7660}

7662template<typename Derived>
7663StmtResult
7664TreeTransform<Derived>::TransformMSDependentExistsStmt(
                                                  MSDependentExistsStmt *S) {
// Transform the nested-name-specifier, if any.
NestedNameSpecifierLoc QualifierLoc;
if (S->getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
  if (!QualifierLoc)
    return StmtError();
}

// Transform the declaration name.
DeclarationNameInfo NameInfo = S->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return StmtError();
}

// Check whether anything changed.
if (!getDerived().AlwaysRebuild() &&
    QualifierLoc == S->getQualifierLoc() &&
    NameInfo.getName() == S->getNameInfo().getName())
  return S;

// Determine whether this name exists, if we can.
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
bool Dependent = false;
switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
case Sema::IER_Exists:
  if (S->isIfExists())
    break;

  return new (getSema().Context) NullStmt(S->getKeywordLoc());

case Sema::IER_DoesNotExist:
  if (S->isIfNotExists())
    break;

  return new (getSema().Context) NullStmt(S->getKeywordLoc());

case Sema::IER_Dependent:
  Dependent = true;
  break;

case Sema::IER_Error:
  return StmtError();
}

// We need to continue with the instantiation, so do so now.
StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// If we have resolved the name, just transform to the substatement.
if (!Dependent)
  return SubStmt;

// The name is still dependent, so build a dependent expression again.
return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
                                                 S->isIfExists(),
                                                 QualifierLoc,
                                                 NameInfo,
                                                 SubStmt.get());
7729}

7731template<typename Derived>
7732ExprResult
7733TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifierLoc()) {
  QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
  getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
if (!PD)
  return ExprError();

ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
  return ExprError();

return new (SemaRef.getASTContext())
    MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
                      SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
                      QualifierLoc, E->getMemberLoc());
7755}

7757template <typename Derived>
7758ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
  MSPropertySubscriptExpr *E) {
auto BaseRes = getDerived().TransformExpr(E->getBase());
if (BaseRes.isInvalid())
  return ExprError();
auto IdxRes = getDerived().TransformExpr(E->getIdx());
if (IdxRes.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    BaseRes.get() == E->getBase() &&
    IdxRes.get() == E->getIdx())
  return E;

return getDerived().RebuildArraySubscriptExpr(
    BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
7774}

7776template <typename Derived>
7777StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
  return StmtError();

StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
if (Handler.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
    Handler.get() == S->getHandler())
  return S;

return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
                                      TryBlock.get(), Handler.get());
7792}

7794template <typename Derived>
7795StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
  return StmtError();

return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
7801}

7803template <typename Derived>
7804StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
if (FilterExpr.isInvalid())
  return StmtError();

StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
  return StmtError();

return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
                                         Block.get());
7815}

7817template <typename Derived>
7818StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
if (isa<SEHFinallyStmt>(Handler))
  return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
else
  return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
7823}

7825template<typename Derived>
7826StmtResult
7827TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
return S;
7829}

7831//===----------------------------------------------------------------------===//
7832// OpenMP directive transformation
7833//===----------------------------------------------------------------------===//
7834template <typename Derived>
7835StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
  OMPExecutableDirective *D) {

// Transform the clauses
llvm::SmallVector<OMPClause *, 16> TClauses;
ArrayRef<OMPClause *> Clauses = D->clauses();
TClauses.reserve(Clauses.size());
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
     I != E; ++I) {
  if (*I) {
    getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
    OMPClause *Clause = getDerived().TransformOMPClause(*I);
    getDerived().getSema().EndOpenMPClause();
    if (Clause)
      TClauses.push_back(Clause);
  } else {
    TClauses.push_back(nullptr);
  }
}
StmtResult AssociatedStmt;
if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
  getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(),
                                                /*CurScope=*/nullptr);
  StmtResult Body;
  {
    Sema::CompoundScopeRAII CompoundScope(getSema());
    Stmt *CS = D->getInnermostCapturedStmt()->getCapturedStmt();
    Body = getDerived().TransformStmt(CS);
  }
  AssociatedStmt =
      getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
  if (AssociatedStmt.isInvalid()) {
    return StmtError();
  }
}
if (TClauses.size() != Clauses.size()) {
  return StmtError();
}

// Transform directive name for 'omp critical' directive.
DeclarationNameInfo DirName;
if (D->getDirectiveKind() == OMPD_critical) {
  DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
  DirName = getDerived().TransformDeclarationNameInfo(DirName);
}
OpenMPDirectiveKind CancelRegion = OMPD_unknown;
if (D->getDirectiveKind() == OMPD_cancellation_point) {
  CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
} else if (D->getDirectiveKind() == OMPD_cancel) {
  CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
}

return getDerived().RebuildOMPExecutableDirective(
    D->getDirectiveKind(), DirName, CancelRegion, TClauses,
    AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc());
7890}

7892template <typename Derived>
7893StmtResult
7894TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7901}

7903template <typename Derived>
7904StmtResult
7905TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7912}

7914template <typename Derived>
7915StmtResult
7916TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7923}

7925template <typename Derived>
7926StmtResult
7927TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7934}

7936template <typename Derived>
7937StmtResult
7938TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7945}

7947template <typename Derived>
7948StmtResult
7949TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7956}

7958template <typename Derived>
7959StmtResult
7960TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7967}

7969template <typename Derived>
7970StmtResult
7971TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7978}

7980template <typename Derived>
7981StmtResult
7982TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7988}

7990template <typename Derived>
7991StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
  OMPParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
7999}

8001template <typename Derived>
8002StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
  OMPParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8010}

8012template <typename Derived>
8013StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
  OMPParallelSectionsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8021}

8023template <typename Derived>
8024StmtResult
8025TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8032}

8034template <typename Derived>
8035StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
  OMPTaskyieldDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8043}

8045template <typename Derived>
8046StmtResult
8047TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8054}

8056template <typename Derived>
8057StmtResult
8058TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8065}

8067template <typename Derived>
8068StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
  OMPTaskgroupDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8076}

8078template <typename Derived>
8079StmtResult
8080TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8087}

8089template <typename Derived>
8090StmtResult
8091TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8098}

8100template <typename Derived>
8101StmtResult
8102TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8109}

8111template <typename Derived>
8112StmtResult
8113TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8120}

8122template <typename Derived>
8123StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
  OMPTargetDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8131}

8133template <typename Derived>
8134StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
  OMPTargetEnterDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8142}

8144template <typename Derived>
8145StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
  OMPTargetExitDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8153}

8155template <typename Derived>
8156StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
  OMPTargetParallelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8164}

8166template <typename Derived>
8167StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
  OMPTargetParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8175}

8177template <typename Derived>
8178StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
  OMPTargetUpdateDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8186}

8188template <typename Derived>
8189StmtResult
8190TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8197}

8199template <typename Derived>
8200StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
  OMPCancellationPointDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8208}

8210template <typename Derived>
8211StmtResult
8212TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8219}

8221template <typename Derived>
8222StmtResult
8223TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8230}

8232template <typename Derived>
8233StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
  OMPTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8241}

8243template <typename Derived>
8244StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
  OMPDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8252}

8254template <typename Derived>
8255StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
  OMPDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8263}

8265template <typename Derived>
8266StmtResult
8267TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
  OMPDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8275}

8277template <typename Derived>
8278StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
  OMPDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8286}

8288template <typename Derived>
8289StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
  OMPTargetParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8297}

8299template <typename Derived>
8300StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
  OMPTargetSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8308}

8310template <typename Derived>
8311StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
  OMPTeamsDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8319}

8321template <typename Derived>
8322StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
  OMPTeamsDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8330}

8332template <typename Derived>
8333StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
  OMPTeamsDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_parallel_for_simd, DirName, nullptr,
    D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8342}

8344template <typename Derived>
8345StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
  OMPTeamsDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8353}

8355template <typename Derived>
8356StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
  OMPTargetTeamsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams, DirName,
                                           nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8364}

8366template <typename Derived>
8367StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
  OMPTargetTeamsDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8375}

8377template <typename Derived>
8378StmtResult
8379TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
  OMPTargetTeamsDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_parallel_for, DirName, nullptr,
    D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8388}

8390template <typename Derived>
8391StmtResult TreeTransform<Derived>::
  TransformOMPTargetTeamsDistributeParallelForSimdDirective(
      OMPTargetTeamsDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr,
    D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8401}

8403template <typename Derived>
8404StmtResult
8405TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
  OMPTargetTeamsDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8413}


8416//===----------------------------------------------------------------------===//
8417// OpenMP clause transformation
8418//===----------------------------------------------------------------------===//
8419template <typename Derived>
8420OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPIfClause(
    C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc());
8427}

8429template <typename Derived>
8430OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
8436}

8438template <typename Derived>
8439OMPClause *
8440TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
if (NumThreads.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumThreadsClause(
    NumThreads.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8446}

8448template <typename Derived>
8449OMPClause *
8450TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSafelen());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPSafelenClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8456}

8458template <typename Derived>
8459OMPClause *
8460TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *C) {
ExprResult E = getDerived().TransformExpr(C->getAllocator());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAllocatorClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8466}

8468template <typename Derived>
8469OMPClause *
8470TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSimdlen());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPSimdlenClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8476}

8478template <typename Derived>
8479OMPClause *
8480TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPCollapseClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8486}

8488template <typename Derived>
8489OMPClause *
8490TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
return getDerived().RebuildOMPDefaultClause(
    C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
8494}

8496template <typename Derived>
8497OMPClause *
8498TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
return getDerived().RebuildOMPProcBindClause(
    C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
8502}

8504template <typename Derived>
8505OMPClause *
8506TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
ExprResult E = getDerived().TransformExpr(C->getChunkSize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPScheduleClause(
    C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
    C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
    C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
8515}

8517template <typename Derived>
8518OMPClause *
8519TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
ExprResult E;
if (auto *Num = C->getNumForLoops()) {
  E = getDerived().TransformExpr(Num);
  if (E.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(),
                                            C->getLParenLoc(), E.get());
8528}

8530template <typename Derived>
8531OMPClause *
8532TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8535}

8537template <typename Derived>
8538OMPClause *
8539TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8542}

8544template <typename Derived>
8545OMPClause *
8546TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8549}

8551template <typename Derived>
8552OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8555}

8557template <typename Derived>
8558OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8561}

8563template <typename Derived>
8564OMPClause *
8565TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8568}

8570template <typename Derived>
8571OMPClause *
8572TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8575}

8577template <typename Derived>
8578OMPClause *
8579TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8582}

8584template <typename Derived>
8585OMPClause *
8586TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8589}

8591template <typename Derived>
8592OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8595}

8597template <typename Derived>
8598OMPClause *
8599TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
8602}

8604template <typename Derived>
8605OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
  OMPUnifiedAddressClause *C) {
llvm_unreachable("unified_address clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("unified_address clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8607);
8608}

8610template <typename Derived>
8611OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
  OMPUnifiedSharedMemoryClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("unified_shared_memory clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8614)
    "unified_shared_memory clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("unified_shared_memory clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8614);
8615}

8617template <typename Derived>
8618OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
  OMPReverseOffloadClause *C) {
llvm_unreachable("reverse_offload clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("reverse_offload clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8620);
8621}

8623template <typename Derived>
8624OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
  OMPDynamicAllocatorsClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("dynamic_allocators clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8627)
    "dynamic_allocators clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("dynamic_allocators clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8627);
8628}

8630template <typename Derived>
8631OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
  OMPAtomicDefaultMemOrderClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("atomic_default_mem_order clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8634)
    "atomic_default_mem_order clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("atomic_default_mem_order clause cannot appear in dependent context"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 8634);
8635}

8637template <typename Derived>
8638OMPClause *
8639TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPPrivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8650}

8652template <typename Derived>
8653OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
  OMPFirstprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPFirstprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8665}

8667template <typename Derived>
8668OMPClause *
8669TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPLastprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8680}

8682template <typename Derived>
8683OMPClause *
8684TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
8695}

8697template <typename Derived>
8698OMPClause *
8699TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(
     UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
        NameInfo, /*ADL=*/true, ULE->isOverloaded(),
        Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
8742}

8744template <typename Derived>
8745OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
  OMPTaskReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
        /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPTaskReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
8787}

8789template <typename Derived>
8790OMPClause *
8791TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
        /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPInReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
8832}

8834template <typename Derived>
8835OMPClause *
8836TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
ExprResult Step = getDerived().TransformExpr(C->getStep());
if (Step.isInvalid())
  return nullptr;
return getDerived().RebuildOMPLinearClause(
    Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(),
    C->getModifierLoc(), C->getColonLoc(), C->getEndLoc());
8851}

8853template <typename Derived>
8854OMPClause *
8855TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
if (Alignment.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAlignedClause(
    Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getColonLoc(), C->getEndLoc());
8870}

8872template <typename Derived>
8873OMPClause *
8874TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
8885}

8887template <typename Derived>
8888OMPClause *
8889TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8900}

8902template <typename Derived>
8903OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
8914}

8916template <typename Derived>
8917OMPClause *
8918TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPDependClause(
    C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(), Vars,
    C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
8930}

8932template <typename Derived>
8933OMPClause *
8934TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
ExprResult E = getDerived().TransformExpr(C->getDevice());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDeviceClause(E.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
8940}

8942template <typename Derived, class T>
8943bool transformOMPMappableExprListClause(
  TreeTransform<Derived> &TT, OMPMappableExprListClause<T> *C,
  llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec,
  DeclarationNameInfo &MapperIdInfo,
  llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) {
// Transform expressions in the list.
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return true;
  Vars.push_back(EVar.get());
}
// Transform mapper scope specifier and identifier.
NestedNameSpecifierLoc QualifierLoc;
if (C->getMapperQualifierLoc()) {
  QualifierLoc = TT.getDerived().TransformNestedNameSpecifierLoc(
      C->getMapperQualifierLoc());
  if (!QualifierLoc)
    return true;
}
MapperIdScopeSpec.Adopt(QualifierLoc);
MapperIdInfo = C->getMapperIdInfo();
if (MapperIdInfo.getName()) {
  MapperIdInfo = TT.getDerived().TransformDeclarationNameInfo(MapperIdInfo);
  if (!MapperIdInfo.getName())
    return true;
}
// Build a list of all candidate OMPDeclareMapperDecls, which is provided by
// the previous user-defined mapper lookup in dependent environment.
for (auto *E : C->mapperlists()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedMappers.push_back(UnresolvedLookupExpr::Create(
        TT.getSema().Context, /*NamingClass=*/nullptr,
        MapperIdScopeSpec.getWithLocInContext(TT.getSema().Context),
        MapperIdInfo, /*ADL=*/true, ULE->isOverloaded(), Decls.begin(),
        Decls.end()));
  } else {
    UnresolvedMappers.push_back(nullptr);
  }
}
return false;
8993}

8995template <typename Derived>
8996OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPMapClause(
    C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), MapperIdScopeSpec,
    MapperIdInfo, C->getMapType(), C->isImplicitMapType(), C->getMapLoc(),
    C->getColonLoc(), Vars, Locs, UnresolvedMappers);
9009}

9011template <typename Derived>
9012OMPClause *
9013TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) {
Expr *Allocator = C->getAllocator();
if (Allocator) {
  ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
  if (AllocatorRes.isInvalid())
    return nullptr;
  Allocator = AllocatorRes.get();
}
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPAllocateClause(
    Allocator, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc());
9032}

9034template <typename Derived>
9035OMPClause *
9036TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTeams());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumTeamsClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9042}

9044template <typename Derived>
9045OMPClause *
9046TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPThreadLimitClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9052}

9054template <typename Derived>
9055OMPClause *
9056TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
ExprResult E = getDerived().TransformExpr(C->getPriority());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPPriorityClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9062}

9064template <typename Derived>
9065OMPClause *
9066TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
ExprResult E = getDerived().TransformExpr(C->getGrainsize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPGrainsizeClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9072}

9074template <typename Derived>
9075OMPClause *
9076TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTasks());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumTasksClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9082}

9084template <typename Derived>
9085OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
ExprResult E = getDerived().TransformExpr(C->getHint());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(),
                                         C->getLParenLoc(), C->getEndLoc());
9091}

9093template <typename Derived>
9094OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
  OMPDistScheduleClause *C) {
ExprResult E = getDerived().TransformExpr(C->getChunkSize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDistScheduleClause(
    C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
9102}

9104template <typename Derived>
9105OMPClause *
9106TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) {
return C;
9108}

9110template <typename Derived>
9111OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPToClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPToClause(Vars, MapperIdScopeSpec, MapperIdInfo,
                                       Locs, UnresolvedMappers);
9122}

9124template <typename Derived>
9125OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPFromClause(
    Vars, MapperIdScopeSpec, MapperIdInfo, Locs, UnresolvedMappers);
9136}

9138template <typename Derived>
9139OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
  OMPUseDevicePtrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPUseDevicePtrClause(Vars, Locs);
9151}

9153template <typename Derived>
9154OMPClause *
9155TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
9166}

9168//===----------------------------------------------------------------------===//
9169// Expression transformation
9170//===----------------------------------------------------------------------===//
9171template<typename Derived>
9172ExprResult
9173TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *E) {
return TransformExpr(E->getSubExpr());
9175}

9177template<typename Derived>
9178ExprResult
9179TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
if (!E->isTypeDependent())
  return E;

return getDerived().RebuildPredefinedExpr(E->getLocation(),
                                          E->getIdentKind());
9185}

9187template<typename Derived>
9188ExprResult
9189TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

ValueDecl *ND
  = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
                                                       E->getDecl()));
if (!ND)
  return ExprError();

NamedDecl *Found = ND;
if (E->getFoundDecl() != E->getDecl()) {
  Found = cast_or_null<NamedDecl>(
      getDerived().TransformDecl(E->getLocation(), E->getFoundDecl()));
  if (!Found)
    return ExprError();
}

DeclarationNameInfo NameInfo = E->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    QualifierLoc == E->getQualifierLoc() &&
    ND == E->getDecl() &&
    Found == E->getFoundDecl() &&
    NameInfo.getName() == E->getDecl()->getDeclName() &&
    !E->hasExplicitTemplateArgs()) {

  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  SemaRef.MarkDeclRefReferenced(E);

  return E;
}

TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
if (E->hasExplicitTemplateArgs()) {
  TemplateArgs = &TransArgs;
  TransArgs.setLAngleLoc(E->getLAngleLoc());
  TransArgs.setRAngleLoc(E->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                              E->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
                                       Found, TemplateArgs);
9246}

9248template<typename Derived>
9249ExprResult
9250TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
return E;
9252}

9254template <typename Derived>
9255ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
  FixedPointLiteral *E) {
return E;
9258}

9260template<typename Derived>
9261ExprResult
9262TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
return E;
9264}

9266template<typename Derived>
9267ExprResult
9268TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
return E;
9270}

9272template<typename Derived>
9273ExprResult
9274TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
return E;
9276}

9278template<typename Derived>
9279ExprResult
9280TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
return E;
9282}

9284template<typename Derived>
9285ExprResult
9286TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
if (FunctionDecl *FD = E->getDirectCallee())
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), FD);
return SemaRef.MaybeBindToTemporary(E);
9290}

9292template<typename Derived>
9293ExprResult
9294TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
ExprResult ControllingExpr =
  getDerived().TransformExpr(E->getControllingExpr());
if (ControllingExpr.isInvalid())
  return ExprError();

SmallVector<Expr *, 4> AssocExprs;
SmallVector<TypeSourceInfo *, 4> AssocTypes;
for (const GenericSelectionExpr::Association &Assoc : E->associations()) {
  TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
  if (TSI) {
    TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
    if (!AssocType)
      return ExprError();
    AssocTypes.push_back(AssocType);
  } else {
    AssocTypes.push_back(nullptr);
  }

  ExprResult AssocExpr =
      getDerived().TransformExpr(Assoc.getAssociationExpr());
  if (AssocExpr.isInvalid())
    return ExprError();
  AssocExprs.push_back(AssocExpr.get());
}

return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
                                                E->getDefaultLoc(),
                                                E->getRParenLoc(),
                                                ControllingExpr.get(),
                                                AssocTypes,
                                                AssocExprs);
9326}

9328template<typename Derived>
9329ExprResult
9330TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
                                     E->getRParen());
9340}

9342/// The operand of a unary address-of operator has special rules: it's
9343/// allowed to refer to a non-static member of a class even if there's no 'this'
9344/// object available.
9345template<typename Derived>
9346ExprResult
9347TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E))
  return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr);
else
  return getDerived().TransformExpr(E);
9352}

9354template<typename Derived>
9355ExprResult
9356TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
ExprResult SubExpr;
if (E->getOpcode() == UO_AddrOf)
  SubExpr = TransformAddressOfOperand(E->getSubExpr());
else
  SubExpr = TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
                                         E->getOpcode(),
                                         SubExpr.get());
9371}

9373template<typename Derived>
9374ExprResult
9375TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
// Transform the type.
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
if (!Type)
  return ExprError();

// Transform all of the components into components similar to what the
// parser uses.
// FIXME: It would be slightly more efficient in the non-dependent case to
// just map FieldDecls, rather than requiring the rebuilder to look for
// the fields again. However, __builtin_offsetof is rare enough in
// template code that we don't care.
bool ExprChanged = false;
typedef Sema::OffsetOfComponent Component;
SmallVector<Component, 4> Components;
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
  const OffsetOfNode &ON = E->getComponent(I);
  Component Comp;
  Comp.isBrackets = true;
  Comp.LocStart = ON.getSourceRange().getBegin();
  Comp.LocEnd = ON.getSourceRange().getEnd();
  switch (ON.getKind()) {
  case OffsetOfNode::Array: {
    Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
    ExprResult Index = getDerived().TransformExpr(FromIndex);
    if (Index.isInvalid())
      return ExprError();

    ExprChanged = ExprChanged || Index.get() != FromIndex;
    Comp.isBrackets = true;
    Comp.U.E = Index.get();
    break;
  }

  case OffsetOfNode::Field:
  case OffsetOfNode::Identifier:
    Comp.isBrackets = false;
    Comp.U.IdentInfo = ON.getFieldName();
    if (!Comp.U.IdentInfo)
      continue;

    break;

  case OffsetOfNode::Base:
    // Will be recomputed during the rebuild.
    continue;
  }

  Components.push_back(Comp);
}

// If nothing changed, retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeSourceInfo() &&
    !ExprChanged)
  return E;

// Build a new offsetof expression.
return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
                                        Components, E->getRParenLoc());
9435}

9437template<typename Derived>
9438ExprResult
9439TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&(((!E->getSourceExpr() || getDerived().AlreadyTransformed(
E->getType())) && "opaque value expression requires transformation"
) ? static_cast<void> (0) : __assert_fail ("(!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && \"opaque value expression requires transformation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9441, __PRETTY_FUNCTION__))
       "opaque value expression requires transformation")(((!E->getSourceExpr() || getDerived().AlreadyTransformed(
E->getType())) && "opaque value expression requires transformation"
) ? static_cast<void> (0) : __assert_fail ("(!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && \"opaque value expression requires transformation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9441, __PRETTY_FUNCTION__));
return E;
9443}

9445template<typename Derived>
9446ExprResult
9447TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
return E;
9449}

9451template<typename Derived>
9452ExprResult
9453TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
// Rebuild the syntactic form.  The original syntactic form has
// opaque-value expressions in it, so strip those away and rebuild
// the result.  This is a really awful way of doing this, but the
// better solution (rebuilding the semantic expressions and
// rebinding OVEs as necessary) doesn't work; we'd need
// TreeTransform to not strip away implicit conversions.
Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
ExprResult result = getDerived().TransformExpr(newSyntacticForm);
if (result.isInvalid()) return ExprError();

// If that gives us a pseudo-object result back, the pseudo-object
// expression must have been an lvalue-to-rvalue conversion which we
// should reapply.
if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
  result = SemaRef.checkPseudoObjectRValue(result.get());

return result;
9471}

9473template<typename Derived>
9474ExprResult
9475TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
                                              UnaryExprOrTypeTraitExpr *E) {
if (E->isArgumentType()) {
  TypeSourceInfo *OldT = E->getArgumentTypeInfo();

  TypeSourceInfo *NewT = getDerived().TransformType(OldT);
  if (!NewT)
    return ExprError();

  if (!getDerived().AlwaysRebuild() && OldT == NewT)
    return E;

  return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
                                                  E->getKind(),
                                                  E->getSourceRange());
}

// C++0x [expr.sizeof]p1:
//   The operand is either an expression, which is an unevaluated operand
//   [...]
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

// Try to recover if we have something like sizeof(T::X) where X is a type.
// Notably, there must be *exactly* one set of parens if X is a type.
TypeSourceInfo *RecoveryTSI = nullptr;
ExprResult SubExpr;
auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
if (auto *DRE =
        PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
  SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
      PE, DRE, false, &RecoveryTSI);
else
  SubExpr = getDerived().TransformExpr(E->getArgumentExpr());

if (RecoveryTSI) {
  return getDerived().RebuildUnaryExprOrTypeTrait(
      RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
} else if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
  return E;

return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
                                                E->getOperatorLoc(),
                                                E->getKind(),
                                                E->getSourceRange());
9524}

9526template<typename Derived>
9527ExprResult
9528TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();


if (!getDerived().AlwaysRebuild() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildArraySubscriptExpr(
    LHS.get(),
    /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
9546}

9548template <typename Derived>
9549ExprResult
9550TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ExprResult LowerBound;
if (E->getLowerBound()) {
  LowerBound = getDerived().TransformExpr(E->getLowerBound());
  if (LowerBound.isInvalid())
    return ExprError();
}

ExprResult Length;
if (E->getLength()) {
  Length = getDerived().TransformExpr(E->getLength());
  if (Length.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
    LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
  return E;

return getDerived().RebuildOMPArraySectionExpr(
    Base.get(), E->getBase()->getEndLoc(), LowerBound.get(), E->getColonLoc(),
    Length.get(), E->getRBracketLoc());
9576}

9578template<typename Derived>
9579ExprResult
9580TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
  = ((Expr *)Callee.get())->getSourceRange().getBegin();
return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                    Args,
                                    E->getRParenLoc());
9604}

9606template<typename Derived>
9607ExprResult
9608TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

NestedNameSpecifierLoc QualifierLoc;
if (E->hasQualifier()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());

  if (!QualifierLoc)
    return ExprError();
}
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

ValueDecl *Member
  = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
                                                       E->getMemberDecl()));
if (!Member)
  return ExprError();

NamedDecl *FoundDecl = E->getFoundDecl();
if (FoundDecl == E->getMemberDecl()) {
  FoundDecl = Member;
} else {
  FoundDecl = cast_or_null<NamedDecl>(
                 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
  if (!FoundDecl)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase() &&
    QualifierLoc == E->getQualifierLoc() &&
    Member == E->getMemberDecl() &&
    FoundDecl == E->getFoundDecl() &&
    !E->hasExplicitTemplateArgs()) {

  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  SemaRef.MarkMemberReferenced(E);

  return E;
}

TemplateArgumentListInfo TransArgs;
if (E->hasExplicitTemplateArgs()) {
  TransArgs.setLAngleLoc(E->getLAngleLoc());
  TransArgs.setRAngleLoc(E->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                              E->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

// FIXME: Bogus source location for the operator
SourceLocation FakeOperatorLoc =
    SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());

// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;
DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
if (MemberNameInfo.getName()) {
  MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
  if (!MemberNameInfo.getName())
    return ExprError();
}

return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
                                      E->isArrow(),
                                      QualifierLoc,
                                      TemplateKWLoc,
                                      MemberNameInfo,
                                      Member,
                                      FoundDecl,
                                      (E->hasExplicitTemplateArgs()
                                         ? &TransArgs : nullptr),
                                      FirstQualifierInScope);
9689}

9691template<typename Derived>
9692ExprResult
9693TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

Sema::FPContractStateRAII FPContractState(getSema());
getSema().FPFeatures = E->getFPFeatures();

return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
                                          LHS.get(), RHS.get());
9712}

9714template<typename Derived>
9715ExprResult
9716TreeTransform<Derived>::TransformCompoundAssignOperator(
                                                    CompoundAssignOperator *E) {
return getDerived().TransformBinaryOperator(E);
9719}

9721template<typename Derived>
9722ExprResult TreeTransform<Derived>::
9723TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
// Just rebuild the common and RHS expressions and see whether we
// get any changes.

ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
if (commonExpr.isInvalid())
  return ExprError();

ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
if (rhs.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    commonExpr.get() == e->getCommon() &&
    rhs.get() == e->getFalseExpr())
  return e;

return getDerived().RebuildConditionalOperator(commonExpr.get(),
                                               e->getQuestionLoc(),
                                               nullptr,
                                               e->getColonLoc(),
                                               rhs.get());
9745}

9747template<typename Derived>
9748ExprResult
9749TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
  return ExprError();

ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == E->getCond() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildConditionalOperator(Cond.get(),
                                               E->getQuestionLoc(),
                                               LHS.get(),
                                               E->getColonLoc(),
                                               RHS.get());
9773}

9775template<typename Derived>
9776ExprResult
9777TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
// Implicit casts are eliminated during transformation, since they
// will be recomputed by semantic analysis after transformation.
return getDerived().TransformExpr(E->getSubExprAsWritten());
9781}

9783template<typename Derived>
9784ExprResult
9785TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
                                          Type,
                                          E->getRParenLoc(),
                                          SubExpr.get());
9804}

9806template<typename Derived>
9807ExprResult
9808TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
TypeSourceInfo *OldT = E->getTypeSourceInfo();
TypeSourceInfo *NewT = getDerived().TransformType(OldT);
if (!NewT)
  return ExprError();

ExprResult Init = getDerived().TransformExpr(E->getInitializer());
if (Init.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    OldT == NewT &&
    Init.get() == E->getInitializer())
  return SemaRef.MaybeBindToTemporary(E);

// Note: the expression type doesn't necessarily match the
// type-as-written, but that's okay, because it should always be
// derivable from the initializer.

return getDerived().RebuildCompoundLiteralExpr(
    E->getLParenLoc(), NewT,
    /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get());
9830}

9832template<typename Derived>
9833ExprResult
9834TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

// FIXME: Bad source location
SourceLocation FakeOperatorLoc =
    SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc());
return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
                                                E->getAccessorLoc(),
                                                E->getAccessor());
9849}

9851template<typename Derived>
9852ExprResult
9853TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
if (InitListExpr *Syntactic = E->getSyntacticForm())
  E = Syntactic;

bool InitChanged = false;

EnterExpressionEvaluationContext Context(
    getSema(), EnterExpressionEvaluationContext::InitList);

SmallVector<Expr*, 4> Inits;
if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
                                Inits, &InitChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() && !InitChanged) {
  // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
  // in some cases. We can't reuse it in general, because the syntactic and
  // semantic forms are linked, and we can't know that semantic form will
  // match even if the syntactic form does.
}

return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
                                    E->getRBraceLoc());
9876}

9878template<typename Derived>
9879ExprResult
9880TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
Designation Desig;

// transform the initializer value
ExprResult Init = getDerived().TransformExpr(E->getInit());
if (Init.isInvalid())
  return ExprError();

// transform the designators.
SmallVector<Expr*, 4> ArrayExprs;
bool ExprChanged = false;
for (const DesignatedInitExpr::Designator &D : E->designators()) {
  if (D.isFieldDesignator()) {
    Desig.AddDesignator(Designator::getField(D.getFieldName(),
                                             D.getDotLoc(),
                                             D.getFieldLoc()));
    if (D.getField()) {
      FieldDecl *Field = cast_or_null<FieldDecl>(
          getDerived().TransformDecl(D.getFieldLoc(), D.getField()));
      if (Field != D.getField())
        // Rebuild the expression when the transformed FieldDecl is
        // different to the already assigned FieldDecl.
        ExprChanged = true;
    } else {
      // Ensure that the designator expression is rebuilt when there isn't
      // a resolved FieldDecl in the designator as we don't want to assign
      // a FieldDecl to a pattern designator that will be instantiated again.
      ExprChanged = true;
    }
    continue;
  }

  if (D.isArrayDesignator()) {
    ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
    if (Index.isInvalid())
      return ExprError();

    Desig.AddDesignator(
        Designator::getArray(Index.get(), D.getLBracketLoc()));

    ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
    ArrayExprs.push_back(Index.get());
    continue;
  }

  assert(D.isArrayRangeDesignator() && "New kind of designator?")((D.isArrayRangeDesignator() && "New kind of designator?"
) ? static_cast<void> (0) : __assert_fail ("D.isArrayRangeDesignator() && \"New kind of designator?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9925, __PRETTY_FUNCTION__));
  ExprResult Start
    = getDerived().TransformExpr(E->getArrayRangeStart(D));
  if (Start.isInvalid())
    return ExprError();

  ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
  if (End.isInvalid())
    return ExprError();

  Desig.AddDesignator(Designator::getArrayRange(Start.get(),
                                                End.get(),
                                                D.getLBracketLoc(),
                                                D.getEllipsisLoc()));

  ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
                End.get() != E->getArrayRangeEnd(D);

  ArrayExprs.push_back(Start.get());
  ArrayExprs.push_back(End.get());
}

if (!getDerived().AlwaysRebuild() &&
    Init.get() == E->getInit() &&
    !ExprChanged)
  return E;

return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
                                              E->getEqualOrColonLoc(),
                                              E->usesGNUSyntax(), Init.get());
9955}

9957// Seems that if TransformInitListExpr() only works on the syntactic form of an
9958// InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
9959template<typename Derived>
9960ExprResult
9961TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
  DesignatedInitUpdateExpr *E) {
llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "::llvm::llvm_unreachable_internal("Unexpected DesignatedInitUpdateExpr in syntactic form of "
 "initializer", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9964)
                 "initializer")::llvm::llvm_unreachable_internal("Unexpected DesignatedInitUpdateExpr in syntactic form of "
 "initializer", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9964);
return ExprError();
9966}

9968template<typename Derived>
9969ExprResult
9970TreeTransform<Derived>::TransformNoInitExpr(
  NoInitExpr *E) {
llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer")::llvm::llvm_unreachable_internal("Unexpected NoInitExpr in syntactic form of initializer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9972);
return ExprError();
9974}

9976template<typename Derived>
9977ExprResult
9978TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer")::llvm::llvm_unreachable_internal("Unexpected ArrayInitLoopExpr outside of initializer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9979);
return ExprError();
9981}

9983template<typename Derived>
9984ExprResult
9985TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer")::llvm::llvm_unreachable_internal("Unexpected ArrayInitIndexExpr outside of initializer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 9986);
return ExprError();
9988}

9990template<typename Derived>
9991ExprResult
9992TreeTransform<Derived>::TransformImplicitValueInitExpr(
                                                   ImplicitValueInitExpr *E) {
TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName());

// FIXME: Will we ever have proper type location here? Will we actually
// need to transform the type?
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getType())
  return E;

return getDerived().RebuildImplicitValueInitExpr(T);
10007}

10009template<typename Derived>
10010ExprResult
10011TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
if (!TInfo)
  return ExprError();

ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    TInfo == E->getWrittenTypeInfo() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
                                     TInfo, E->getRParenLoc());
10027}

10029template<typename Derived>
10030ExprResult
10031TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 4> Inits;
if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
                   &ArgumentChanged))
  return ExprError();

return getDerived().RebuildParenListExpr(E->getLParenLoc(),
                                         Inits,
                                         E->getRParenLoc());
10041}

10043/// Transform an address-of-label expression.
10044///
10045/// By default, the transformation of an address-of-label expression always
10046/// rebuilds the expression, so that the label identifier can be resolved to
10047/// the corresponding label statement by semantic analysis.
10048template<typename Derived>
10049ExprResult
10050TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
                                      E->getLabel());
if (!LD)
  return ExprError();

return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
                                         cast<LabelDecl>(LD));
10058}

10060template<typename Derived>
10061ExprResult
10062TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
SemaRef.ActOnStartStmtExpr();
StmtResult SubStmt
  = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
if (SubStmt.isInvalid()) {
  SemaRef.ActOnStmtExprError();
  return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    SubStmt.get() == E->getSubStmt()) {
  // Calling this an 'error' is unintuitive, but it does the right thing.
  SemaRef.ActOnStmtExprError();
  return SemaRef.MaybeBindToTemporary(E);
}

return getDerived().RebuildStmtExpr(E->getLParenLoc(),
                                    SubStmt.get(),
                                    E->getRParenLoc());
10081}

10083template<typename Derived>
10084ExprResult
10085TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
  return ExprError();

ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == E->getCond() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
                                      Cond.get(), LHS.get(), RHS.get(),
                                      E->getRParenLoc());
10107}

10109template<typename Derived>
10110ExprResult
10111TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
return E;
10113}

10115template<typename Derived>
10116ExprResult
10117TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
switch (E->getOperator()) {
case OO_New:
case OO_Delete:
case OO_Array_New:
case OO_Array_Delete:
  llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr")::llvm::llvm_unreachable_internal("new and delete operators cannot use CXXOperatorCallExpr"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 10123);

case OO_Call: {
  // This is a call to an object's operator().
  assert(E->getNumArgs() >= 1 && "Object call is missing arguments")((E->getNumArgs() >= 1 && "Object call is missing arguments"
) ? static_cast<void> (0) : __assert_fail ("E->getNumArgs() >= 1 && \"Object call is missing arguments\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 10127, __PRETTY_FUNCTION__));

  // Transform the object itself.
  ExprResult Object = getDerived().TransformExpr(E->getArg(0));
  if (Object.isInvalid())
    return ExprError();

  // FIXME: Poor location information
  SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
      static_cast<Expr *>(Object.get())->getEndLoc());

  // Transform the call arguments.
  SmallVector<Expr*, 8> Args;
  if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
                                  Args))
    return ExprError();

  return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args,
                                      E->getEndLoc());
}

10148#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
case OO_##Name:
10150#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
10151#include "clang/Basic/OperatorKinds.def"
case OO_Subscript:
  // Handled below.
  break;

case OO_Conditional:
  llvm_unreachable("conditional operator is not actually overloadable")::llvm::llvm_unreachable_internal("conditional operator is not actually overloadable"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 10157);

case OO_None:
case NUM_OVERLOADED_OPERATORS:
  llvm_unreachable("not an overloaded operator?")::llvm::llvm_unreachable_internal("not an overloaded operator?"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 10161);
}

ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

ExprResult First;
if (E->getOperator() == OO_Amp)
  First = getDerived().TransformAddressOfOperand(E->getArg(0));
else
  First = getDerived().TransformExpr(E->getArg(0));
if (First.isInvalid())
  return ExprError();

ExprResult Second;
if (E->getNumArgs() == 2) {
  Second = getDerived().TransformExpr(E->getArg(1));
  if (Second.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    First.get() == E->getArg(0) &&
    (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
  return SemaRef.MaybeBindToTemporary(E);

Sema::FPContractStateRAII FPContractState(getSema());
getSema().FPFeatures = E->getFPFeatures();

return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
                                               E->getOperatorLoc(),
                                               Callee.get(),
                                               First.get(),
                                               Second.get());
10197}

10199template<typename Derived>
10200ExprResult
10201TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
return getDerived().TransformCallExpr(E);
10203}

10205template <typename Derived>
10206ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
bool NeedRebuildFunc = E->getIdentKind() == SourceLocExpr::Function &&
                       getSema().CurContext != E->getParentContext();

if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
  return E;

return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getBeginLoc(),
                                         E->getEndLoc(),
                                         getSema().CurContext);
10216}

10218template<typename Derived>
10219ExprResult
10220TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

// Transform exec config.
ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
if (EC.isInvalid())
  return ExprError();

// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
  = ((Expr *)Callee.get())->getSourceRange().getBegin();
return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                    Args,
                                    E->getRParenLoc(), EC.get());
10249}

10251template<typename Derived>
10252ExprResult
10253TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;
return getDerived().RebuildCXXNamedCastExpr(
    E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
    Type, E->getAngleBrackets().getEnd(),
    // FIXME. this should be '(' location
    E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
10272}

10274template<typename Derived>
10275ExprResult
10276TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
TypeSourceInfo *TSI =
    getDerived().TransformType(BCE->getTypeInfoAsWritten());
if (!TSI)
  return ExprError();

ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
if (Sub.isInvalid())
  return ExprError();

return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
                                              Sub.get(), BCE->getEndLoc());
10288}

10290template<typename Derived>
10291ExprResult
10292TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
10294}

10296template<typename Derived>
10297ExprResult
10298TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
10300}

10302template<typename Derived>
10303ExprResult
10304TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
                                                    CXXReinterpretCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
10307}

10309template<typename Derived>
10310ExprResult
10311TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
10313}

10315template<typename Derived>
10316ExprResult
10317TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
                                                   CXXFunctionalCastExpr *E) {
TypeSourceInfo *Type =
    getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCXXFunctionalCastExpr(Type,
                                                 E->getLParenLoc(),
                                                 SubExpr.get(),
                                                 E->getRParenLoc(),
                                                 E->isListInitialization());
10339}

10341template<typename Derived>
10342ExprResult
10343TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
if (E->isTypeOperand()) {
  TypeSourceInfo *TInfo
    = getDerived().TransformType(E->getTypeOperandSourceInfo());
  if (!TInfo)
    return ExprError();

  if (!getDerived().AlwaysRebuild() &&
      TInfo == E->getTypeOperandSourceInfo())
    return E;

  return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
                                           TInfo, E->getEndLoc());
}

// We don't know whether the subexpression is potentially evaluated until
// after we perform semantic analysis.  We speculatively assume it is
// unevaluated; it will get fixed later if the subexpression is in fact
// potentially evaluated.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getExprOperand())
  return E;

return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
                                         SubExpr.get(), E->getEndLoc());
10376}

10378template<typename Derived>
10379ExprResult
10380TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
if (E->isTypeOperand()) {
  TypeSourceInfo *TInfo
    = getDerived().TransformType(E->getTypeOperandSourceInfo());
  if (!TInfo)
    return ExprError();

  if (!getDerived().AlwaysRebuild() &&
      TInfo == E->getTypeOperandSourceInfo())
    return E;

  return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
                                           TInfo, E->getEndLoc());
}

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);

ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getExprOperand())
  return E;

return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
                                         SubExpr.get(), E->getEndLoc());
10408}

10410template<typename Derived>
10411ExprResult
10412TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
return E;
10414}

10416template<typename Derived>
10417ExprResult
10418TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
                                                   CXXNullPtrLiteralExpr *E) {
return E;
10421}

10423template<typename Derived>
10424ExprResult
10425TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
QualType T = getSema().getCurrentThisType();

if (!getDerived().AlwaysRebuild() && T == E->getType()) {
  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  getSema().MarkThisReferenced(E);
  return E;
}

return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit());
10436}

10438template<typename Derived>
10439ExprResult
10440TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
                                        E->isThrownVariableInScope());
10451}

10453template<typename Derived>
10454ExprResult
10455TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
if (!Param)
  return ExprError();

if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
    E->getUsedContext() == SemaRef.CurContext)
  return E;

return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
10466}

10468template<typename Derived>
10469ExprResult
10470TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
FieldDecl *Field = cast_or_null<FieldDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
if (!Field)
  return ExprError();

if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
    E->getUsedContext() == SemaRef.CurContext)
  return E;

return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
10481}

10483template<typename Derived>
10484ExprResult
10485TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
                                                  CXXScalarValueInitExpr *E) {
TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
if (!T)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo())
  return E;

return getDerived().RebuildCXXScalarValueInitExpr(T,
                                        /*FIXME:*/T->getTypeLoc().getEndLoc(),
                                                  E->getRParenLoc());
10498}

10500template<typename Derived>
10501ExprResult
10502TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
// Transform the type that we're allocating
TypeSourceInfo *AllocTypeInfo =
    getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
if (!AllocTypeInfo)
  return ExprError();

// Transform the size of the array we're allocating (if any).
Optional<Expr *> ArraySize;
if (Optional<Expr *> OldArraySize = E->getArraySize()) {
  ExprResult NewArraySize;
  if (*OldArraySize) {
    NewArraySize = getDerived().TransformExpr(*OldArraySize);
    if (NewArraySize.isInvalid())
      return ExprError();
  }
  ArraySize = NewArraySize.get();
}

// Transform the placement arguments (if any).
bool ArgumentChanged = false;
SmallVector<Expr*, 8> PlacementArgs;
if (getDerived().TransformExprs(E->getPlacementArgs(),
                                E->getNumPlacementArgs(), true,
                                PlacementArgs, &ArgumentChanged))
  return ExprError();

// Transform the initializer (if any).
Expr *OldInit = E->getInitializer();
ExprResult NewInit;
if (OldInit)
  NewInit = getDerived().TransformInitializer(OldInit, true);
if (NewInit.isInvalid())
  return ExprError();

// Transform new operator and delete operator.
FunctionDecl *OperatorNew = nullptr;
if (E->getOperatorNew()) {
  OperatorNew = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
  if (!OperatorNew)
    return ExprError();
}

FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
  OperatorDelete = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
  if (!OperatorDelete)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
    ArraySize == E->getArraySize() &&
    NewInit.get() == OldInit &&
    OperatorNew == E->getOperatorNew() &&
    OperatorDelete == E->getOperatorDelete() &&
    !ArgumentChanged) {
  // Mark any declarations we need as referenced.
  // FIXME: instantiation-specific.
  if (OperatorNew)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew);
  if (OperatorDelete)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);

  if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
    QualType ElementType
      = SemaRef.Context.getBaseElementType(E->getAllocatedType());
    if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
      if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
        SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor);
      }
    }
  }

  return E;
}

QualType AllocType = AllocTypeInfo->getType();
if (!ArraySize) {
  // If no array size was specified, but the new expression was
  // instantiated with an array type (e.g., "new T" where T is
  // instantiated with "int[4]"), extract the outer bound from the
  // array type as our array size. We do this with constant and
  // dependently-sized array types.
  const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
  if (!ArrayT) {
    // Do nothing
  } else if (const ConstantArrayType *ConsArrayT
                                   = dyn_cast<ConstantArrayType>(ArrayT)) {
    ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
                                       SemaRef.Context.getSizeType(),
                                       /*FIXME:*/ E->getBeginLoc());
    AllocType = ConsArrayT->getElementType();
  } else if (const DependentSizedArrayType *DepArrayT
                            = dyn_cast<DependentSizedArrayType>(ArrayT)) {
    if (DepArrayT->getSizeExpr()) {
      ArraySize = DepArrayT->getSizeExpr();
      AllocType = DepArrayT->getElementType();
    }
  }
}

return getDerived().RebuildCXXNewExpr(
    E->getBeginLoc(), E->isGlobalNew(),
    /*FIXME:*/ E->getBeginLoc(), PlacementArgs,
    /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
    AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
10612}

10614template<typename Derived>
10615ExprResult
10616TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
ExprResult Operand = getDerived().TransformExpr(E->getArgument());
if (Operand.isInvalid())
  return ExprError();

// Transform the delete operator, if known.
FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
  OperatorDelete = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
  if (!OperatorDelete)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Operand.get() == E->getArgument() &&
    OperatorDelete == E->getOperatorDelete()) {
  // Mark any declarations we need as referenced.
  // FIXME: instantiation-specific.
  if (OperatorDelete)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);

  if (!E->getArgument()->isTypeDependent()) {
    QualType Destroyed = SemaRef.Context.getBaseElementType(
                                                       E->getDestroyedType());
    if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
      SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
                                     SemaRef.LookupDestructor(Record));
    }
  }

  return E;
}

return getDerived().RebuildCXXDeleteExpr(
    E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get());
10653}

10655template<typename Derived>
10656ExprResult
10657TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
                                                   CXXPseudoDestructorExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ParsedType ObjectTypePtr;
bool MayBePseudoDestructor = false;
Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
                                            E->getOperatorLoc(),
                                      E->isArrow()? tok::arrow : tok::period,
                                            ObjectTypePtr,
                                            MayBePseudoDestructor);
if (Base.isInvalid())
  return ExprError();

QualType ObjectType = ObjectTypePtr.get();
NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
  if (!QualifierLoc)
    return ExprError();
}
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

PseudoDestructorTypeStorage Destroyed;
if (E->getDestroyedTypeInfo()) {
  TypeSourceInfo *DestroyedTypeInfo
    = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
                                              ObjectType, nullptr, SS);
  if (!DestroyedTypeInfo)
    return ExprError();
  Destroyed = DestroyedTypeInfo;
} else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
  // We aren't likely to be able to resolve the identifier down to a type
  // now anyway, so just retain the identifier.
  Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
                                          E->getDestroyedTypeLoc());
} else {
  // Look for a destructor known with the given name.
  ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
                                            *E->getDestroyedTypeIdentifier(),
                                              E->getDestroyedTypeLoc(),
                                              /*Scope=*/nullptr,
                                              SS, ObjectTypePtr,
                                              false);
  if (!T)
    return ExprError();

  Destroyed
    = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
                                               E->getDestroyedTypeLoc());
}

TypeSourceInfo *ScopeTypeInfo = nullptr;
if (E->getScopeTypeInfo()) {
  CXXScopeSpec EmptySS;
  ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
                    E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
  if (!ScopeTypeInfo)
    return ExprError();
}

return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
                                                   E->getOperatorLoc(),
                                                   E->isArrow(),
                                                   SS,
                                                   ScopeTypeInfo,
                                                   E->getColonColonLoc(),
                                                   E->getTildeLoc(),
                                                   Destroyed);
10730}

10732template <typename Derived>
10733bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old,
                                                      bool RequiresADL,
                                                      LookupResult &R) {
// Transform all the decls.
bool AllEmptyPacks = true;
for (auto *OldD : Old->decls()) {
  Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
  if (!InstD) {
    // Silently ignore these if a UsingShadowDecl instantiated to nothing.
    // This can happen because of dependent hiding.
    if (isa<UsingShadowDecl>(OldD))
      continue;
    else {
      R.clear();
      return true;
    }
  }

  // Expand using pack declarations.
  NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
  ArrayRef<NamedDecl*> Decls = SingleDecl;
  if (auto *UPD = dyn_cast<UsingPackDecl>(InstD))
    Decls = UPD->expansions();

  // Expand using declarations.
  for (auto *D : Decls) {
    if (auto *UD = dyn_cast<UsingDecl>(D)) {
      for (auto *SD : UD->shadows())
        R.addDecl(SD);
    } else {
      R.addDecl(D);
    }
  }

  AllEmptyPacks &= Decls.empty();
};

// C++ [temp.res]/8.4.2:
//   The program is ill-formed, no diagnostic required, if [...] lookup for
//   a name in the template definition found a using-declaration, but the
//   lookup in the corresponding scope in the instantiation odoes not find
//   any declarations because the using-declaration was a pack expansion and
//   the corresponding pack is empty
if (AllEmptyPacks && !RequiresADL) {
  getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
      << isa<UnresolvedMemberExpr>(Old) << Old->getName();
  return true;
}

// Resolve a kind, but don't do any further analysis.  If it's
// ambiguous, the callee needs to deal with it.
R.resolveKind();
return false;
10786}

10788template<typename Derived>
10789ExprResult
10790TreeTransform<Derived>::TransformUnresolvedLookupExpr(
                                                UnresolvedLookupExpr *Old) {
LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
               Sema::LookupOrdinaryName);

// Transform the declaration set.
if (TransformOverloadExprDecls(Old, Old->requiresADL(), R))
  return ExprError();

// Rebuild the nested-name qualifier, if present.
CXXScopeSpec SS;
if (Old->getQualifierLoc()) {
  NestedNameSpecifierLoc QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();

  SS.Adopt(QualifierLoc);
}

if (Old->getNamingClass()) {
  CXXRecordDecl *NamingClass
    = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
                                                          Old->getNameLoc(),
                                                      Old->getNamingClass()));
  if (!NamingClass) {
    R.clear();
    return ExprError();
  }

  R.setNamingClass(NamingClass);
}

SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();

// If we have neither explicit template arguments, nor the template keyword,
// it's a normal declaration name or member reference.
if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
  NamedDecl *D = R.getAsSingle<NamedDecl>();
  // In a C++11 unevaluated context, an UnresolvedLookupExpr might refer to an
  // instance member. In other contexts, BuildPossibleImplicitMemberExpr will
  // give a good diagnostic.
  if (D && D->isCXXInstanceMember()) {
    return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
                                                   /*TemplateArgs=*/nullptr,
                                                   /*Scope=*/nullptr);
  }

  return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
}

// If we have template arguments, rebuild them, then rebuild the
// templateid expression.
TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
if (Old->hasExplicitTemplateArgs() &&
    getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                            Old->getNumTemplateArgs(),
                                            TransArgs)) {
  R.clear();
  return ExprError();
}

return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
                                          Old->requiresADL(), &TransArgs);
10854}

10856template<typename Derived>
10857ExprResult
10858TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
bool ArgChanged = false;
SmallVector<TypeSourceInfo *, 4> Args;
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
  TypeSourceInfo *From = E->getArg(I);
  TypeLoc FromTL = From->getTypeLoc();
  if (!FromTL.getAs<PackExpansionTypeLoc>()) {
    TypeLocBuilder TLB;
    TLB.reserve(FromTL.getFullDataSize());
    QualType To = getDerived().TransformType(TLB, FromTL);
    if (To.isNull())
      return ExprError();

    if (To == From->getType())
      Args.push_back(From);
    else {
      Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
      ArgChanged = true;
    }
    continue;
  }

  ArgChanged = true;

  // We have a pack expansion. Instantiate it.
  PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
  TypeLoc PatternTL = ExpansionTL.getPatternLoc();
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  Optional<unsigned> OrigNumExpansions =
      ExpansionTL.getTypePtr()->getNumExpansions();
  Optional<unsigned> NumExpansions = OrigNumExpansions;
  if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                           PatternTL.getSourceRange(),
                                           Unexpanded,
                                           Expand, RetainExpansion,
                                           NumExpansions))
    return ExprError();

  if (!Expand) {
    // The transform has determined that we should perform a simple
    // transformation on the pack expansion, producing another pack
    // expansion.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

    TypeLocBuilder TLB;
    TLB.reserve(From->getTypeLoc().getFullDataSize());

    QualType To = getDerived().TransformType(TLB, PatternTL);
    if (To.isNull())
      return ExprError();

    To = getDerived().RebuildPackExpansionType(To,
                                               PatternTL.getSourceRange(),
                                               ExpansionTL.getEllipsisLoc(),
                                               NumExpansions);
    if (To.isNull())
      return ExprError();

    PackExpansionTypeLoc ToExpansionTL
      = TLB.push<PackExpansionTypeLoc>(To);
    ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
    Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
    continue;
  }

  // Expand the pack expansion by substituting for each argument in the
  // pack(s).
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
    TypeLocBuilder TLB;
    TLB.reserve(PatternTL.getFullDataSize());
    QualType To = getDerived().TransformType(TLB, PatternTL);
    if (To.isNull())
      return ExprError();

    if (To->containsUnexpandedParameterPack()) {
      To = getDerived().RebuildPackExpansionType(To,
                                                 PatternTL.getSourceRange(),
                                                 ExpansionTL.getEllipsisLoc(),
                                                 NumExpansions);
      if (To.isNull())
        return ExprError();

      PackExpansionTypeLoc ToExpansionTL
        = TLB.push<PackExpansionTypeLoc>(To);
      ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
    }

    Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
  }

  if (!RetainExpansion)
    continue;

  // If we're supposed to retain a pack expansion, do so by temporarily
  // forgetting the partially-substituted parameter pack.
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  TypeLocBuilder TLB;
  TLB.reserve(From->getTypeLoc().getFullDataSize());

  QualType To = getDerived().TransformType(TLB, PatternTL);
  if (To.isNull())
    return ExprError();

  To = getDerived().RebuildPackExpansionType(To,
                                             PatternTL.getSourceRange(),
                                             ExpansionTL.getEllipsisLoc(),
                                             NumExpansions);
  if (To.isNull())
    return ExprError();

  PackExpansionTypeLoc ToExpansionTL
    = TLB.push<PackExpansionTypeLoc>(To);
  ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
  Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
}

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return E;

return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
                                     E->getEndLoc());
10987}

10989template<typename Derived>
10990ExprResult
10991TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
if (!T)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getQueriedTypeSourceInfo())
  return E;

ExprResult SubExpr;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
  SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
  if (SubExpr.isInvalid())
    return ExprError();

  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
    return E;
}

return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T,
                                          SubExpr.get(), E->getEndLoc());
11014}

11016template<typename Derived>
11017ExprResult
11018TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
ExprResult SubExpr;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
  SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
  if (SubExpr.isInvalid())
    return ExprError();

  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
    return E;
}

return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(),
                                           SubExpr.get(), E->getEndLoc());
11033}

11035template <typename Derived>
11036ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
  ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
  TypeSourceInfo **RecoveryTSI) {
ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
    DRE, AddrTaken, RecoveryTSI);

// Propagate both errors and recovered types, which return ExprEmpty.
if (!NewDRE.isUsable())
  return NewDRE;

// We got an expr, wrap it up in parens.
if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
  return PE;
return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
                                     PE->getRParen());
11051}

11053template <typename Derived>
11054ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
  DependentScopeDeclRefExpr *E) {
return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
                                          nullptr);
11058}

11060template<typename Derived>
11061ExprResult
11062TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
                                             DependentScopeDeclRefExpr *E,
                                             bool IsAddressOfOperand,
                                             TypeSourceInfo **RecoveryTSI) {
assert(E->getQualifierLoc())((E->getQualifierLoc()) ? static_cast<void> (0) : __assert_fail
 ("E->getQualifierLoc()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 11066, __PRETTY_FUNCTION__));
NestedNameSpecifierLoc QualifierLoc
= getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
if (!QualifierLoc)
  return ExprError();
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.

DeclarationNameInfo NameInfo
  = getDerived().TransformDeclarationNameInfo(E->getNameInfo());
if (!NameInfo.getName())
  return ExprError();

if (!E->hasExplicitTemplateArgs()) {
  if (!getDerived().AlwaysRebuild() &&
      QualifierLoc == E->getQualifierLoc() &&
      // Note: it is sufficient to compare the Name component of NameInfo:
      // if name has not changed, DNLoc has not changed either.
      NameInfo.getName() == E->getDeclName())
    return E;

  return getDerived().RebuildDependentScopeDeclRefExpr(
      QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
      IsAddressOfOperand, RecoveryTSI);
}

TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                            E->getNumTemplateArgs(),
                                            TransArgs))
  return ExprError();

return getDerived().RebuildDependentScopeDeclRefExpr(
    QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
    RecoveryTSI);
11104}

11106template<typename Derived>
11107ExprResult
11108TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
// CXXConstructExprs other than for list-initialization and
// CXXTemporaryObjectExpr are always implicit, so when we have
// a 1-argument construction we just transform that argument.
if ((E->getNumArgs() == 1 ||
     (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
    (!getDerived().DropCallArgument(E->getArg(0))) &&
    !E->isListInitialization())
  return getDerived().TransformExpr(E->getArg(0));

TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());

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

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                  &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getType() &&
    Constructor == E->getConstructor() &&
    !ArgumentChanged) {
  // Mark the constructor as referenced.
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return E;
}

return getDerived().RebuildCXXConstructExpr(
    T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
    E->hadMultipleCandidates(), E->isListInitialization(),
    E->isStdInitListInitialization(), E->requiresZeroInitialization(),
    E->getConstructionKind(), E->getParenOrBraceRange());
11155}

11157template<typename Derived>
11158ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
  CXXInheritedCtorInitExpr *E) {
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getType() &&
    Constructor == E->getConstructor()) {
  // Mark the constructor as referenced.
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return E;
}

return getDerived().RebuildCXXInheritedCtorInitExpr(
    T, E->getLocation(), Constructor,
    E->constructsVBase(), E->inheritedFromVBase());
11181}

11183/// Transform a C++ temporary-binding expression.
11184///
11185/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
11186/// transform the subexpression and return that.
11187template<typename Derived>
11188ExprResult
11189TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
return getDerived().TransformExpr(E->getSubExpr());
11191}

11193/// Transform a C++ expression that contains cleanups that should
11194/// be run after the expression is evaluated.
11195///
11196/// Since ExprWithCleanups nodes are implicitly generated, we
11197/// just transform the subexpression and return that.
11198template<typename Derived>
11199ExprResult
11200TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
return getDerived().TransformExpr(E->getSubExpr());
11202}

11204template<typename Derived>
11205ExprResult
11206TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
                                                  CXXTemporaryObjectExpr *E) {
TypeSourceInfo *T =
    getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                     &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo() &&
    Constructor == E->getConstructor() &&
    !ArgumentChanged) {
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return SemaRef.MaybeBindToTemporary(E);
}

// FIXME: We should just pass E->isListInitialization(), but we're not
// prepared to handle list-initialization without a child InitListExpr.
SourceLocation LParenLoc = T->getTypeLoc().getEndLoc();
return getDerived().RebuildCXXTemporaryObjectExpr(
    T, LParenLoc, Args, E->getEndLoc(),
    /*ListInitialization=*/LParenLoc.isInvalid());
11245}

11247template<typename Derived>
11248ExprResult
11249TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
// Transform any init-capture expressions before entering the scope of the
// lambda body, because they are not semantically within that scope.
typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
struct TransformedInitCapture {
  // The location of the ... if the result is retaining a pack expansion.
  SourceLocation EllipsisLoc;
  // Zero or more expansions of the init-capture.
  SmallVector<InitCaptureInfoTy, 4> Expansions;
};
SmallVector<TransformedInitCapture, 4> InitCaptures;
InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                  CEnd = E->capture_end();
     C != CEnd; ++C) {
  if (!E->isInitCapture(C))
    continue;

  TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
  VarDecl *OldVD = C->getCapturedVar();

  auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
                              Optional<unsigned> NumExpansions) {
    ExprResult NewExprInitResult = getDerived().TransformInitializer(
        OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);

    if (NewExprInitResult.isInvalid()) {
      Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType()));
      return;
    }
    Expr *NewExprInit = NewExprInitResult.get();

    QualType NewInitCaptureType =
        getSema().buildLambdaInitCaptureInitialization(
            C->getLocation(), OldVD->getType()->isReferenceType(),
            EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
            C->getCapturedVar()->getInitStyle() != VarDecl::CInit,
            NewExprInit);
    Result.Expansions.push_back(
        InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
  };

  // If this is an init-capture pack, consider expanding the pack now.
  if (OldVD->isParameterPack()) {
    PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
                                           ->getTypeLoc()
                                           .castAs<PackExpansionTypeLoc>();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded);

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    Optional<unsigned> OrigNumExpansions =
        ExpansionTL.getTypePtr()->getNumExpansions();
    Optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(
            ExpansionTL.getEllipsisLoc(),
            OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
            RetainExpansion, NumExpansions))
      return ExprError();
    if (Expand) {
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        SubstInitCapture(SourceLocation(), None);
      }
    }
    if (!Expand || RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());
      SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
      Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
    }
  } else {
    SubstInitCapture(SourceLocation(), None);
  }
}

LambdaScopeInfo *LSI = getSema().PushLambdaScope();
Sema::FunctionScopeRAII FuncScopeCleanup(getSema());

// Transform the template parameters, and add them to the current
// instantiation scope. The null case is handled correctly.
auto TPL = getDerived().TransformTemplateParameterList(
    E->getTemplateParameterList());
LSI->GLTemplateParameterList = TPL;

// Transform the type of the original lambda's call operator.
// The transformation MUST be done in the CurrentInstantiationScope since
// it introduces a mapping of the original to the newly created
// transformed parameters.
TypeSourceInfo *NewCallOpTSI = nullptr;
{
  TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
  FunctionProtoTypeLoc OldCallOpFPTL =
      OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();

  TypeLocBuilder NewCallOpTLBuilder;
  SmallVector<QualType, 4> ExceptionStorage;
  TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
  QualType NewCallOpType = TransformFunctionProtoType(
      NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(),
      [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
        return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
                                            ExceptionStorage, Changed);
      });
  if (NewCallOpType.isNull())
    return ExprError();
  NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
                                                      NewCallOpType);
}

// Create the local class that will describe the lambda.
CXXRecordDecl *OldClass = E->getLambdaClass();
CXXRecordDecl *Class
  = getSema().createLambdaClosureType(E->getIntroducerRange(),
                                      NewCallOpTSI,
                                      /*KnownDependent=*/false,
                                      E->getCaptureDefault());
getDerived().transformedLocalDecl(OldClass, {Class});

Optional<std::pair<unsigned, Decl*>> Mangling;
if (getDerived().ReplacingOriginal())
  Mangling = std::make_pair(OldClass->getLambdaManglingNumber(),
                            OldClass->getLambdaContextDecl());

// Build the call operator.
CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
    Class, E->getIntroducerRange(), NewCallOpTSI,
    E->getCallOperator()->getEndLoc(),
    NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
    E->getCallOperator()->getConstexprKind(), Mangling);

LSI->CallOperator = NewCallOperator;

for (unsigned I = 0, NumParams = NewCallOperator->getNumParams();
     I != NumParams; ++I) {
  auto *P = NewCallOperator->getParamDecl(I);
  if (P->hasUninstantiatedDefaultArg()) {
    EnterExpressionEvaluationContext Eval(
        getSema(),
        Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed, P);
    ExprResult R = getDerived().TransformExpr(
        E->getCallOperator()->getParamDecl(I)->getDefaultArg());
    P->setDefaultArg(R.get());
  }
}

getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});

// Introduce the context of the call operator.
Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
                               /*NewThisContext*/false);

// Enter the scope of the lambda.
getSema().buildLambdaScope(LSI, NewCallOperator,
                           E->getIntroducerRange(),
                           E->getCaptureDefault(),
                           E->getCaptureDefaultLoc(),
                           E->hasExplicitParameters(),
                           E->hasExplicitResultType(),
                           E->isMutable());

bool Invalid = false;

// Transform captures.
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (C->isImplicit())
    break;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
    getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
                                  /*BuildAndDiagnose*/ true, nullptr,
                                  C->getCaptureKind() == LCK_StarThis);
    continue;
  }
  // Captured expression will be recaptured during captured variables
  // rebuilding.
  if (C->capturesVLAType())
    continue;

  // Rebuild init-captures, including the implied field declaration.
  if (E->isInitCapture(C)) {
    TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];

    VarDecl *OldVD = C->getCapturedVar();
    llvm::SmallVector<Decl*, 4> NewVDs;

    for (InitCaptureInfoTy &Info : NewC.Expansions) {
      ExprResult Init = Info.first;
      QualType InitQualType = Info.second;
      if (Init.isInvalid() || InitQualType.isNull()) {
        Invalid = true;
        break;
      }
      VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
          OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
          OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get());
      if (!NewVD) {
        Invalid = true;
        break;
      }
      NewVDs.push_back(NewVD);
      getSema().addInitCapture(LSI, NewVD);
    }

    if (Invalid)
      break;

    getDerived().transformedLocalDecl(OldVD, NewVDs);
    continue;
  }

  assert(C->capturesVariable() && "unexpected kind of lambda capture")((C->capturesVariable() && "unexpected kind of lambda capture"
) ? static_cast<void> (0) : __assert_fail ("C->capturesVariable() && \"unexpected kind of lambda capture\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 11468, __PRETTY_FUNCTION__));

  // Determine the capture kind for Sema.
  Sema::TryCaptureKind Kind
    = C->isImplicit()? Sema::TryCapture_Implicit
                     : C->getCaptureKind() == LCK_ByCopy
                         ? Sema::TryCapture_ExplicitByVal
                         : Sema::TryCapture_ExplicitByRef;
  SourceLocation EllipsisLoc;
  if (C->isPackExpansion()) {
    UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    Optional<unsigned> NumExpansions;
    if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
                                             C->getLocation(),
                                             Unexpanded,
                                             ShouldExpand, RetainExpansion,
                                             NumExpansions)) {
      Invalid = true;
      continue;
    }

    if (ShouldExpand) {
      // The transform has determined that we should perform an expansion;
      // transform and capture each of the arguments.
      // expansion of the pattern. Do so.
      VarDecl *Pack = C->getCapturedVar();
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        VarDecl *CapturedVar
          = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
                                                             Pack));
        if (!CapturedVar) {
          Invalid = true;
          continue;
        }

        // Capture the transformed variable.
        getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
      }

      // FIXME: Retain a pack expansion if RetainExpansion is true.

      continue;
    }

    EllipsisLoc = C->getEllipsisLoc();
  }

  // Transform the captured variable.
  VarDecl *CapturedVar
    = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
                                                       C->getCapturedVar()));
  if (!CapturedVar || CapturedVar->isInvalidDecl()) {
    Invalid = true;
    continue;
  }

  // Capture the transformed variable.
  getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
                               EllipsisLoc);
}
getSema().finishLambdaExplicitCaptures(LSI);

// FIXME: Sema's lambda-building mechanism expects us to push an expression
// evaluation context even if we're not transforming the function body.
getSema().PushExpressionEvaluationContext(
    Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// Instantiate the body of the lambda expression.
StmtResult Body =
    Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody());

// ActOnLambda* will pop the function scope for us.
FuncScopeCleanup.disable();

if (Body.isInvalid()) {
  SavedContext.pop();
  getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr,
                             /*IsInstantiation=*/true);
  return ExprError();
}

// Copy the LSI before ActOnFinishFunctionBody removes it.
// FIXME: This is dumb. Store the lambda information somewhere that outlives
// the call operator.
auto LSICopy = *LSI;
getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
                                  /*IsInstantiation*/ true);
SavedContext.pop();

return getSema().BuildLambdaExpr(E->getBeginLoc(), Body.get()->getEndLoc(),
                                 &LSICopy);
11562}

11564template<typename Derived>
11565StmtResult
11566TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) {
return TransformStmt(S);
11568}

11570template<typename Derived>
11571StmtResult
11572TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) {
// Transform captures.
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (!C->isImplicit())
    continue;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
    getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
                                  /*BuildAndDiagnose*/ true, nullptr,
                                  C->getCaptureKind() == LCK_StarThis);
    continue;
  }
  // Captured expression will be recaptured during captured variables
  // rebuilding.
  if (C->capturesVLAType())
    continue;

  assert(C->capturesVariable() && "unexpected kind of lambda capture")((C->capturesVariable() && "unexpected kind of lambda capture"
) ? static_cast<void> (0) : __assert_fail ("C->capturesVariable() && \"unexpected kind of lambda capture\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 11594, __PRETTY_FUNCTION__));
  assert(!E->isInitCapture(C) && "implicit init-capture?")((!E->isInitCapture(C) && "implicit init-capture?"
) ? static_cast<void> (0) : __assert_fail ("!E->isInitCapture(C) && \"implicit init-capture?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 11595, __PRETTY_FUNCTION__));

  // Transform the captured variable.
  VarDecl *CapturedVar = cast_or_null<VarDecl>(
      getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
  if (!CapturedVar || CapturedVar->isInvalidDecl())
    return StmtError();

  // Capture the transformed variable.
  getSema().tryCaptureVariable(CapturedVar, C->getLocation());
}

return S;
11608}

11610template<typename Derived>
11611ExprResult
11612TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
                                                CXXUnresolvedConstructExpr *E) {
TypeSourceInfo *T =
    getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->arg_size());
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args,
                                  &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo() &&
    !ArgumentChanged)
  return E;

// FIXME: we're faking the locations of the commas
return getDerived().RebuildCXXUnresolvedConstructExpr(
    T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization());
11639}

11641template<typename Derived>
11642ExprResult
11643TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
                                           CXXDependentScopeMemberExpr *E) {
// Transform the base of the expression.
ExprResult Base((Expr*) nullptr);
Expr *OldBase;
QualType BaseType;
QualType ObjectType;
if (!E->isImplicitAccess()) {
  OldBase = E->getBase();
  Base = getDerived().TransformExpr(OldBase);
  if (Base.isInvalid())
    return ExprError();

  // Start the member reference and compute the object's type.
  ParsedType ObjectTy;
  bool MayBePseudoDestructor = false;
  Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
                                              E->getOperatorLoc(),
                                    E->isArrow()? tok::arrow : tok::period,
                                              ObjectTy,
                                              MayBePseudoDestructor);
  if (Base.isInvalid())
    return ExprError();

  ObjectType = ObjectTy.get();
  BaseType = ((Expr*) Base.get())->getType();
} else {
  OldBase = nullptr;
  BaseType = getDerived().TransformType(E->getBaseType());
  ObjectType = BaseType->getAs<PointerType>()->getPointeeType();
}

// Transform the first part of the nested-name-specifier that qualifies
// the member name.
NamedDecl *FirstQualifierInScope
  = getDerived().TransformFirstQualifierInScope(
                                          E->getFirstQualifierFoundInScope(),
                                          E->getQualifierLoc().getBeginLoc());

NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifier()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
                                                   ObjectType,
                                                   FirstQualifierInScope);
  if (!QualifierLoc)
    return ExprError();
}

SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.

DeclarationNameInfo NameInfo
  = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
if (!NameInfo.getName())
  return ExprError();

if (!E->hasExplicitTemplateArgs()) {
  // This is a reference to a member without an explicitly-specified
  // template argument list. Optimize for this common case.
  if (!getDerived().AlwaysRebuild() &&
      Base.get() == OldBase &&
      BaseType == E->getBaseType() &&
      QualifierLoc == E->getQualifierLoc() &&
      NameInfo.getName() == E->getMember() &&
      FirstQualifierInScope == E->getFirstQualifierFoundInScope())
    return E;

  return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
                                                     BaseType,
                                                     E->isArrow(),
                                                     E->getOperatorLoc(),
                                                     QualifierLoc,
                                                     TemplateKWLoc,
                                                     FirstQualifierInScope,
                                                     NameInfo,
                                                     /*TemplateArgs*/nullptr);
}

TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                            E->getNumTemplateArgs(),
                                            TransArgs))
  return ExprError();

return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
                                                   BaseType,
                                                   E->isArrow(),
                                                   E->getOperatorLoc(),
                                                   QualifierLoc,
                                                   TemplateKWLoc,
                                                   FirstQualifierInScope,
                                                   NameInfo,
                                                   &TransArgs);
11740}

11742template<typename Derived>
11743ExprResult
11744TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
// Transform the base of the expression.
ExprResult Base((Expr*) nullptr);
QualType BaseType;
if (!Old->isImplicitAccess()) {
  Base = getDerived().TransformExpr(Old->getBase());
  if (Base.isInvalid())
    return ExprError();
  Base = getSema().PerformMemberExprBaseConversion(Base.get(),
                                                   Old->isArrow());
  if (Base.isInvalid())
    return ExprError();
  BaseType = Base.get()->getType();
} else {
  BaseType = getDerived().TransformType(Old->getBaseType());
}

NestedNameSpecifierLoc QualifierLoc;
if (Old->getQualifierLoc()) {
  QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();

LookupResult R(SemaRef, Old->getMemberNameInfo(),
               Sema::LookupOrdinaryName);

// Transform the declaration set.
if (TransformOverloadExprDecls(Old, /*RequiresADL*/false, R))
  return ExprError();

// Determine the naming class.
if (Old->getNamingClass()) {
  CXXRecordDecl *NamingClass
    = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
                                                        Old->getMemberLoc(),
                                                      Old->getNamingClass()));
  if (!NamingClass)
    return ExprError();

  R.setNamingClass(NamingClass);
}

TemplateArgumentListInfo TransArgs;
if (Old->hasExplicitTemplateArgs()) {
  TransArgs.setLAngleLoc(Old->getLAngleLoc());
  TransArgs.setRAngleLoc(Old->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                              Old->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;

return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
                                                BaseType,
                                                Old->getOperatorLoc(),
                                                Old->isArrow(),
                                                QualifierLoc,
                                                TemplateKWLoc,
                                                FirstQualifierInScope,
                                                R,
                                            (Old->hasExplicitTemplateArgs()
                                                ? &TransArgs : nullptr));
11816}

11818template<typename Derived>
11819ExprResult
11820TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
  return E;

return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
11831}

11833template<typename Derived>
11834ExprResult
11835TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
if (Pattern.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
  return E;

return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
                                         E->getNumExpansions());
11845}

11847template<typename Derived>
11848ExprResult
11849TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
// If E is not value-dependent, then nothing will change when we transform it.
// Note: This is an instantiation-centric view.
if (!E->isValueDependent())
  return E;

EnterExpressionEvaluationContext Unevaluated(
    getSema(), Sema::ExpressionEvaluationContext::Unevaluated);

ArrayRef<TemplateArgument> PackArgs;
TemplateArgument ArgStorage;

// Find the argument list to transform.
if (E->isPartiallySubstituted()) {
  PackArgs = E->getPartialArguments();
} else if (E->isValueDependent()) {
  UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
  bool ShouldExpand = false;
  bool RetainExpansion = false;
  Optional<unsigned> NumExpansions;
  if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
                                           Unexpanded,
                                           ShouldExpand, RetainExpansion,
                                           NumExpansions))
    return ExprError();

  // If we need to expand the pack, build a template argument from it and
  // expand that.
  if (ShouldExpand) {
    auto *Pack = E->getPack();
    if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
      ArgStorage = getSema().Context.getPackExpansionType(
          getSema().Context.getTypeDeclType(TTPD), None);
    } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
      ArgStorage = TemplateArgument(TemplateName(TTPD), None);
    } else {
      auto *VD = cast<ValueDecl>(Pack);
      ExprResult DRE = getSema().BuildDeclRefExpr(
          VD, VD->getType().getNonLValueExprType(getSema().Context),
          VD->getType()->isReferenceType() ? VK_LValue : VK_RValue,
          E->getPackLoc());
      if (DRE.isInvalid())
        return ExprError();
      ArgStorage = new (getSema().Context) PackExpansionExpr(
          getSema().Context.DependentTy, DRE.get(), E->getPackLoc(), None);
    }
    PackArgs = ArgStorage;
  }
}

// If we're not expanding the pack, just transform the decl.
if (!PackArgs.size()) {
  auto *Pack = cast_or_null<NamedDecl>(
      getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
  if (!Pack)
    return ExprError();
  return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
                                            E->getPackLoc(),
                                            E->getRParenLoc(), None, None);
}

// Try to compute the result without performing a partial substitution.
Optional<unsigned> Result = 0;
for (const TemplateArgument &Arg : PackArgs) {
  if (!Arg.isPackExpansion()) {
    Result = *Result + 1;
    continue;
  }

  TemplateArgumentLoc ArgLoc;
  InventTemplateArgumentLoc(Arg, ArgLoc);

  // Find the pattern of the pack expansion.
  SourceLocation Ellipsis;
  Optional<unsigned> OrigNumExpansions;
  TemplateArgumentLoc Pattern =
      getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
                                                        OrigNumExpansions);

  // Substitute under the pack expansion. Do not expand the pack (yet).
  TemplateArgumentLoc OutPattern;
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
  if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
                                             /*Uneval*/ true))
    return true;

  // See if we can determine the number of arguments from the result.
  Optional<unsigned> NumExpansions =
      getSema().getFullyPackExpandedSize(OutPattern.getArgument());
  if (!NumExpansions) {
    // No: we must be in an alias template expansion, and we're going to need
    // to actually expand the packs.
    Result = None;
    break;
  }

  Result = *Result + *NumExpansions;
}

// Common case: we could determine the number of expansions without
// substituting.
if (Result)
  return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
                                            E->getPackLoc(),
                                            E->getRParenLoc(), *Result, None);

TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
                                             E->getPackLoc());
{
  TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
  typedef TemplateArgumentLocInventIterator<
      Derived, const TemplateArgument*> PackLocIterator;
  if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
                                 PackLocIterator(*this, PackArgs.end()),
                                 TransformedPackArgs, /*Uneval*/true))
    return ExprError();
}

// Check whether we managed to fully-expand the pack.
// FIXME: Is it possible for us to do so and not hit the early exit path?
SmallVector<TemplateArgument, 8> Args;
bool PartialSubstitution = false;
for (auto &Loc : TransformedPackArgs.arguments()) {
  Args.push_back(Loc.getArgument());
  if (Loc.getArgument().isPackExpansion())
    PartialSubstitution = true;
}

if (PartialSubstitution)
  return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
                                            E->getPackLoc(),
                                            E->getRParenLoc(), None, Args);

return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
                                          E->getPackLoc(), E->getRParenLoc(),
                                          Args.size(), None);
11985}

11987template<typename Derived>
11988ExprResult
11989TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
                                        SubstNonTypeTemplateParmPackExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
11993}

11995template<typename Derived>
11996ExprResult
11997TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
                                        SubstNonTypeTemplateParmExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
12001}

12003template<typename Derived>
12004ExprResult
12005TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
12008}

12010template<typename Derived>
12011ExprResult
12012TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
                                                MaterializeTemporaryExpr *E) {
return getDerived().TransformExpr(E->GetTemporaryExpr());
12015}

12017template<typename Derived>
12018ExprResult
12019TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
Expr *Pattern = E->getPattern();

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? static_cast<void> (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12024, __PRETTY_FUNCTION__));

// Determine whether the set of unexpanded parameter packs can and should
// be expanded.
bool Expand = true;
bool RetainExpansion = false;
Optional<unsigned> OrigNumExpansions = E->getNumExpansions(),
                   NumExpansions = OrigNumExpansions;
if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
                                         Pattern->getSourceRange(),
                                         Unexpanded,
                                         Expand, RetainExpansion,
                                         NumExpansions))
  return true;

if (!Expand) {
  // Do not expand any packs here, just transform and rebuild a fold
  // expression.
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

  ExprResult LHS =
      E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
  if (LHS.isInvalid())
    return true;

  ExprResult RHS =
      E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
  if (RHS.isInvalid())
    return true;

  if (!getDerived().AlwaysRebuild() &&
      LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
    return E;

  return getDerived().RebuildCXXFoldExpr(
      E->getBeginLoc(), LHS.get(), E->getOperator(), E->getEllipsisLoc(),
      RHS.get(), E->getEndLoc(), NumExpansions);
}

// The transform has determined that we should perform an elementwise
// expansion of the pattern. Do so.
ExprResult Result = getDerived().TransformExpr(E->getInit());
if (Result.isInvalid())
  return true;
bool LeftFold = E->isLeftFold();

// If we're retaining an expansion for a right fold, it is the innermost
// component and takes the init (if any).
if (!LeftFold && RetainExpansion) {
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  Result = getDerived().RebuildCXXFoldExpr(
      E->getBeginLoc(), Out.get(), E->getOperator(), E->getEllipsisLoc(),
      Result.get(), E->getEndLoc(), OrigNumExpansions);
  if (Result.isInvalid())
    return true;
}

for (unsigned I = 0; I != *NumExpansions; ++I) {
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
      getSema(), LeftFold ? I : *NumExpansions - I - 1);
  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  if (Out.get()->containsUnexpandedParameterPack()) {
    // We still have a pack; retain a pack expansion for this slice.
    Result = getDerived().RebuildCXXFoldExpr(
        E->getBeginLoc(), LeftFold ? Result.get() : Out.get(),
        E->getOperator(), E->getEllipsisLoc(),
        LeftFold ? Out.get() : Result.get(), E->getEndLoc(),
        OrigNumExpansions);
  } else if (Result.isUsable()) {
    // We've got down to a single element; build a binary operator.
    Result = getDerived().RebuildBinaryOperator(
        E->getEllipsisLoc(), E->getOperator(),
        LeftFold ? Result.get() : Out.get(),
        LeftFold ? Out.get() : Result.get());
  } else
    Result = Out;

  if (Result.isInvalid())
    return true;
}

// If we're retaining an expansion for a left fold, it is the outermost
// component and takes the complete expansion so far as its init (if any).
if (LeftFold && RetainExpansion) {
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  Result = getDerived().RebuildCXXFoldExpr(
      E->getBeginLoc(), Result.get(), E->getOperator(), E->getEllipsisLoc(),
      Out.get(), E->getEndLoc(), OrigNumExpansions);
  if (Result.isInvalid())
    return true;
}

// If we had no init and an empty pack, and we're not retaining an expansion,
// then produce a fallback value or error.
if (Result.isUnset())
  return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
                                              E->getOperator());

return Result;
12136}

12138template<typename Derived>
12139ExprResult
12140TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
  CXXStdInitializerListExpr *E) {
return getDerived().TransformExpr(E->getSubExpr());
12143}

12145template<typename Derived>
12146ExprResult
12147TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
return SemaRef.MaybeBindToTemporary(E);
12149}

12151template<typename Derived>
12152ExprResult
12153TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
return E;
12155}

12157template<typename Derived>
12158ExprResult
12159TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
12169}

12171template<typename Derived>
12172ExprResult
12173TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
// Transform each of the elements.
SmallVector<Expr *, 8> Elements;
bool ArgChanged = false;
if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
                                /*IsCall=*/false, Elements, &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
                                            Elements.data(),
                                            Elements.size());
12187}

12189template<typename Derived>
12190ExprResult
12191TreeTransform<Derived>::TransformObjCDictionaryLiteral(
                                                  ObjCDictionaryLiteral *E) {
// Transform each of the elements.
SmallVector<ObjCDictionaryElement, 8> Elements;
bool ArgChanged = false;
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
  ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);

  if (OrigElement.isPackExpansion()) {
    // This key/value element is a pack expansion.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
    getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? static_cast<void> (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12204, __PRETTY_FUNCTION__));

    // Determine whether the set of unexpanded parameter packs can
    // and should be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
    Optional<unsigned> NumExpansions = OrigNumExpansions;
    SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
                             OrigElement.Value->getEndLoc());
    if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
                                             PatternRange, Unexpanded, Expand,
                                             RetainExpansion, NumExpansions))
      return ExprError();

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
      if (Key.isInvalid())
        return ExprError();

      if (Key.get() != OrigElement.Key)
        ArgChanged = true;

      ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
      if (Value.isInvalid())
        return ExprError();

      if (Value.get() != OrigElement.Value)
        ArgChanged = true;

      ObjCDictionaryElement Expansion = {
        Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
      };
      Elements.push_back(Expansion);
      continue;
    }

    // Record right away that the argument was changed.  This needs
    // to happen even if the array expands to nothing.
    ArgChanged = true;

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
      ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
      if (Key.isInvalid())
        return ExprError();

      ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
      if (Value.isInvalid())
        return ExprError();

      ObjCDictionaryElement Element = {
        Key.get(), Value.get(), SourceLocation(), NumExpansions
      };

      // If any unexpanded parameter packs remain, we still have a
      // pack expansion.
      // FIXME: Can this really happen?
      if (Key.get()->containsUnexpandedParameterPack() ||
          Value.get()->containsUnexpandedParameterPack())
        Element.EllipsisLoc = OrigElement.EllipsisLoc;

      Elements.push_back(Element);
    }

    // FIXME: Retain a pack expansion if RetainExpansion is true.

    // We've finished with this pack expansion.
    continue;
  }

  // Transform and check key.
  ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
  if (Key.isInvalid())
    return ExprError();

  if (Key.get() != OrigElement.Key)
    ArgChanged = true;

  // Transform and check value.
  ExprResult Value
    = getDerived().TransformExpr(OrigElement.Value);
  if (Value.isInvalid())
    return ExprError();

  if (Value.get() != OrigElement.Value)
    ArgChanged = true;

  ObjCDictionaryElement Element = {
    Key.get(), Value.get(), SourceLocation(), None
  };
  Elements.push_back(Element);
}

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
                                                 Elements);
12309}

12311template<typename Derived>
12312ExprResult
12313TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
TypeSourceInfo *EncodedTypeInfo
  = getDerived().TransformType(E->getEncodedTypeSourceInfo());
if (!EncodedTypeInfo)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    EncodedTypeInfo == E->getEncodedTypeSourceInfo())
  return E;

return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
                                          EncodedTypeInfo,
                                          E->getRParenLoc());
12326}

12328template<typename Derived>
12329ExprResult TreeTransform<Derived>::
12330TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
// This is a kind of implicit conversion, and it needs to get dropped
// and recomputed for the same general reasons that ImplicitCastExprs
// do, as well a more specific one: this expression is only valid when
// it appears *immediately* as an argument expression.
return getDerived().TransformExpr(E->getSubExpr());
12336}

12338template<typename Derived>
12339ExprResult TreeTransform<Derived>::
12340TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
TypeSourceInfo *TSInfo
  = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!TSInfo)
  return ExprError();

ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
if (Result.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    TSInfo == E->getTypeInfoAsWritten() &&
    Result.get() == E->getSubExpr())
  return E;

return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
                                    E->getBridgeKeywordLoc(), TSInfo,
                                    Result.get());
12358}

12360template <typename Derived>
12361ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
  ObjCAvailabilityCheckExpr *E) {
return E;
12364}

12366template<typename Derived>
12367ExprResult
12368TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
                                &ArgChanged))
  return ExprError();

if (E->getReceiverKind() == ObjCMessageExpr::Class) {
  // Class message: transform the receiver type.
  TypeSourceInfo *ReceiverTypeInfo
    = getDerived().TransformType(E->getClassReceiverTypeInfo());
  if (!ReceiverTypeInfo)
    return ExprError();

  // If nothing changed, just retain the existing message send.
  if (!getDerived().AlwaysRebuild() &&
      ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
    return SemaRef.MaybeBindToTemporary(E);

  // Build a new class message send.
  SmallVector<SourceLocation, 16> SelLocs;
  E->getSelectorLocs(SelLocs);
  return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
                                             E->getSelector(),
                                             SelLocs,
                                             E->getMethodDecl(),
                                             E->getLeftLoc(),
                                             Args,
                                             E->getRightLoc());
}
else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
         E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
  if (!E->getMethodDecl())
    return ExprError();

  // Build a new class message send to 'super'.
  SmallVector<SourceLocation, 16> SelLocs;
  E->getSelectorLocs(SelLocs);
  return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
                                             E->getSelector(),
                                             SelLocs,
                                             E->getReceiverType(),
                                             E->getMethodDecl(),
                                             E->getLeftLoc(),
                                             Args,
                                             E->getRightLoc());
}

// Instance message: transform the receiver
assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&((E->getReceiverKind() == ObjCMessageExpr::Instance &&
 "Only class and instance messages may be instantiated") ? static_cast
<void> (0) : __assert_fail ("E->getReceiverKind() == ObjCMessageExpr::Instance && \"Only class and instance messages may be instantiated\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12420, __PRETTY_FUNCTION__))
       "Only class and instance messages may be instantiated")((E->getReceiverKind() == ObjCMessageExpr::Instance &&
 "Only class and instance messages may be instantiated") ? static_cast
<void> (0) : __assert_fail ("E->getReceiverKind() == ObjCMessageExpr::Instance && \"Only class and instance messages may be instantiated\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12420, __PRETTY_FUNCTION__));
ExprResult Receiver
  = getDerived().TransformExpr(E->getInstanceReceiver());
if (Receiver.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing message send.
if (!getDerived().AlwaysRebuild() &&
    Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// Build a new instance message send.
SmallVector<SourceLocation, 16> SelLocs;
E->getSelectorLocs(SelLocs);
return getDerived().RebuildObjCMessageExpr(Receiver.get(),
                                           E->getSelector(),
                                           SelLocs,
                                           E->getMethodDecl(),
                                           E->getLeftLoc(),
                                           Args,
                                           E->getRightLoc());
12441}

12443template<typename Derived>
12444ExprResult
12445TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
return E;
12447}

12449template<typename Derived>
12450ExprResult
12451TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
return E;
12453}

12455template<typename Derived>
12456ExprResult
12457TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// We don't need to transform the ivar; it will never change.

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
                                           E->getLocation(),
                                           E->isArrow(), E->isFreeIvar());
12473}

12475template<typename Derived>
12476ExprResult
12477TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
// 'super' and types never change. Property never changes. Just
// retain the existing expression.
if (!E->isObjectReceiver())
  return E;

// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// We don't need to transform the property; it will never change.

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

if (E->isExplicitProperty())
  return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
                                                 E->getExplicitProperty(),
                                                 E->getLocation());

return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
                                               SemaRef.Context.PseudoObjectTy,
                                               E->getImplicitPropertyGetter(),
                                               E->getImplicitPropertySetter(),
                                               E->getLocation());
12505}

12507template<typename Derived>
12508ExprResult
12509TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
  return ExprError();

// Transform the key expression.
ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
if (Key.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
  return E;

return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
                                                Base.get(), Key.get(),
                                                E->getAtIndexMethodDecl(),
                                                E->setAtIndexMethodDecl());
12529}

12531template<typename Derived>
12532ExprResult
12533TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
                                       E->getOpLoc(),
                                       E->isArrow());
12547}

12549template<typename Derived>
12550ExprResult
12551TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 8> SubExprs;
SubExprs.reserve(E->getNumSubExprs());
if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
                                SubExprs, &ArgumentChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    !ArgumentChanged)
  return E;

return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
                                             SubExprs,
                                             E->getRParenLoc());
12566}

12568template<typename Derived>
12569ExprResult
12570TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
if (SrcExpr.isInvalid())
  return ExprError();

TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
if (!Type)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeSourceInfo() &&
    SrcExpr.get() == E->getSrcExpr())
  return E;

return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
                                             SrcExpr.get(), Type,
                                             E->getRParenLoc());
12587}

12589template<typename Derived>
12590ExprResult
12591TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
BlockDecl *oldBlock = E->getBlockDecl();

SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
BlockScopeInfo *blockScope = SemaRef.getCurBlock();

blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
blockScope->TheDecl->setBlockMissingReturnType(
                       oldBlock->blockMissingReturnType());

SmallVector<ParmVarDecl*, 4> params;
SmallVector<QualType, 4> paramTypes;

const FunctionProtoType *exprFunctionType = E->getFunctionType();

// Parameter substitution.
Sema::ExtParameterInfoBuilder extParamInfos;
if (getDerived().TransformFunctionTypeParams(
        E->getCaretLocation(), oldBlock->parameters(), nullptr,
        exprFunctionType->getExtParameterInfosOrNull(), paramTypes, &params,
        extParamInfos)) {
  getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
  return ExprError();
}

QualType exprResultType =
    getDerived().TransformType(exprFunctionType->getReturnType());

auto epi = exprFunctionType->getExtProtoInfo();
epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());

QualType functionType =
  getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
blockScope->FunctionType = functionType;

// Set the parameters on the block decl.
if (!params.empty())
  blockScope->TheDecl->setParams(params);

if (!oldBlock->blockMissingReturnType()) {
  blockScope->HasImplicitReturnType = false;
  blockScope->ReturnType = exprResultType;
}

// Transform the body
StmtResult body = getDerived().TransformStmt(E->getBody());
if (body.isInvalid()) {
  getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
  return ExprError();
}

12642#ifndef NDEBUG
// In builds with assertions, make sure that we captured everything we
// captured before.
if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
  for (const auto &I : oldBlock->captures()) {
    VarDecl *oldCapture = I.getVariable();

    // Ignore parameter packs.
    if (oldCapture->isParameterPack())
      continue;

    VarDecl *newCapture =
      cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
                                               oldCapture));
    assert(blockScope->CaptureMap.count(newCapture))((blockScope->CaptureMap.count(newCapture)) ? static_cast<
void> (0) : __assert_fail ("blockScope->CaptureMap.count(newCapture)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12656, __PRETTY_FUNCTION__));
  }
  assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured())((oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured
()) ? static_cast<void> (0) : __assert_fail ("oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12658, __PRETTY_FUNCTION__));
}
12660#endif

return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
                                  /*Scope=*/nullptr);
12664}

12666template<typename Derived>
12667ExprResult
12668TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
llvm_unreachable("Cannot transform asType expressions yet")::llvm::llvm_unreachable_internal("Cannot transform asType expressions yet"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12669);
12670}

12672template<typename Derived>
12673ExprResult
12674TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 8> SubExprs;
SubExprs.reserve(E->getNumSubExprs());
if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
                                SubExprs, &ArgumentChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    !ArgumentChanged)
  return E;

return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
                                      E->getOp(), E->getRParenLoc());
12688}

12690//===----------------------------------------------------------------------===//
12691// Type reconstruction
12692//===----------------------------------------------------------------------===//

12694template<typename Derived>
12695QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
                                                  SourceLocation Star) {
return SemaRef.BuildPointerType(PointeeType, Star,
                                getDerived().getBaseEntity());
12699}

12701template<typename Derived>
12702QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
                                                       SourceLocation Star) {
return SemaRef.BuildBlockPointerType(PointeeType, Star,
                                     getDerived().getBaseEntity());
12706}

12708template<typename Derived>
12709QualType
12710TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
                                           bool WrittenAsLValue,
                                           SourceLocation Sigil) {
return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
                                  Sigil, getDerived().getBaseEntity());
12715}

12717template<typename Derived>
12718QualType
12719TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
                                               QualType ClassType,
                                               SourceLocation Sigil) {
return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
                                      getDerived().getBaseEntity());
12724}

12726template<typename Derived>
12727QualType TreeTransform<Derived>::RebuildObjCTypeParamType(
         const ObjCTypeParamDecl *Decl,
         SourceLocation ProtocolLAngleLoc,
         ArrayRef<ObjCProtocolDecl *> Protocols,
         ArrayRef<SourceLocation> ProtocolLocs,
         SourceLocation ProtocolRAngleLoc) {
return SemaRef.BuildObjCTypeParamType(Decl,
                                      ProtocolLAngleLoc, Protocols,
                                      ProtocolLocs, ProtocolRAngleLoc,
                                      /*FailOnError=*/true);
12737}

12739template<typename Derived>
12740QualType TreeTransform<Derived>::RebuildObjCObjectType(
         QualType BaseType,
         SourceLocation Loc,
         SourceLocation TypeArgsLAngleLoc,
         ArrayRef<TypeSourceInfo *> TypeArgs,
         SourceLocation TypeArgsRAngleLoc,
         SourceLocation ProtocolLAngleLoc,
         ArrayRef<ObjCProtocolDecl *> Protocols,
         ArrayRef<SourceLocation> ProtocolLocs,
         SourceLocation ProtocolRAngleLoc) {
return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
                                   TypeArgs, TypeArgsRAngleLoc,
                                   ProtocolLAngleLoc, Protocols, ProtocolLocs,
                                   ProtocolRAngleLoc,
                                   /*FailOnError=*/true);
12755}

12757template<typename Derived>
12758QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
         QualType PointeeType,
         SourceLocation Star) {
return SemaRef.Context.getObjCObjectPointerType(PointeeType);
12762}

12764template<typename Derived>
12765QualType
12766TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
                                       ArrayType::ArraySizeModifier SizeMod,
                                       const llvm::APInt *Size,
                                       Expr *SizeExpr,
                                       unsigned IndexTypeQuals,
                                       SourceRange BracketsRange) {
if (SizeExpr || !Size)
  return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
                                IndexTypeQuals, BracketsRange,
                                getDerived().getBaseEntity());

QualType Types[] = {
  SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
  SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
  SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
};
const unsigned NumTypes = llvm::array_lengthof(Types);
QualType SizeType;
for (unsigned I = 0; I != NumTypes; ++I)
  if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
    SizeType = Types[I];
    break;
  }

// Note that we can return a VariableArrayType here in the case where
// the element type was a dependent VariableArrayType.
IntegerLiteral *ArraySize
    = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType,
                             /*FIXME*/BracketsRange.getBegin());
return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
                              IndexTypeQuals, BracketsRange,
                              getDerived().getBaseEntity());
12798}

12800template<typename Derived>
12801QualType
12802TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
                                               ArrayType::ArraySizeModifier SizeMod,
                                               const llvm::APInt &Size,
                                               unsigned IndexTypeQuals,
                                               SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, nullptr,
                                      IndexTypeQuals, BracketsRange);
12809}

12811template<typename Derived>
12812QualType
12813TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                               unsigned IndexTypeQuals,
                                                 SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
                                     IndexTypeQuals, BracketsRange);
12819}

12821template<typename Derived>
12822QualType
12823TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                               Expr *SizeExpr,
                                               unsigned IndexTypeQuals,
                                               SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
                                     SizeExpr,
                                     IndexTypeQuals, BracketsRange);
12831}

12833template<typename Derived>
12834QualType
12835TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                                     Expr *SizeExpr,
                                                     unsigned IndexTypeQuals,
                                                 SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
                                     SizeExpr,
                                     IndexTypeQuals, BracketsRange);
12843}

12845template <typename Derived>
12846QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType(
  QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
return SemaRef.BuildAddressSpaceAttr(PointeeType, AddrSpaceExpr,
                                        AttributeLoc);
12850}

12852template <typename Derived>
12853QualType
12854TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
                                        unsigned NumElements,
                                        VectorType::VectorKind VecKind) {
// FIXME: semantic checking!
return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
12859}

12861template <typename Derived>
12862QualType TreeTransform<Derived>::RebuildDependentVectorType(
  QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc,
  VectorType::VectorKind VecKind) {
return SemaRef.BuildVectorType(ElementType, SizeExpr, AttributeLoc);
12866}

12868template<typename Derived>
12869QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
                                                    unsigned NumElements,
                                               SourceLocation AttributeLoc) {
llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
                        NumElements, true);
IntegerLiteral *VectorSize
  = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy,
                           AttributeLoc);
return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
12878}

12880template<typename Derived>
12881QualType
12882TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
                                                         Expr *SizeExpr,
                                                SourceLocation AttributeLoc) {
return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
12886}

12888template<typename Derived>
12889QualType TreeTransform<Derived>::RebuildFunctionProtoType(
  QualType T,
  MutableArrayRef<QualType> ParamTypes,
  const FunctionProtoType::ExtProtoInfo &EPI) {
return SemaRef.BuildFunctionType(T, ParamTypes,
                                 getDerived().getBaseLocation(),
                                 getDerived().getBaseEntity(),
                                 EPI);
12897}

12899template<typename Derived>
12900QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
return SemaRef.Context.getFunctionNoProtoType(T);
12902}

12904template<typename Derived>
12905QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc,
                                                          Decl *D) {
assert(D && "no decl found")((D && "no decl found") ? static_cast<void> (0)
 : __assert_fail ("D && \"no decl found\"", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12907, __PRETTY_FUNCTION__));
if (D->isInvalidDecl()) return QualType();

// FIXME: Doesn't account for ObjCInterfaceDecl!
TypeDecl *Ty;
if (auto *UPD = dyn_cast<UsingPackDecl>(D)) {
  // A valid resolved using typename pack expansion decl can have multiple
  // UsingDecls, but they must each have exactly one type, and it must be
  // the same type in every case. But we must have at least one expansion!
  if (UPD->expansions().empty()) {
    getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
        << UPD->isCXXClassMember() << UPD;
    return QualType();
  }

  // We might still have some unresolved types. Try to pick a resolved type
  // if we can. The final instantiation will check that the remaining
  // unresolved types instantiate to the type we pick.
  QualType FallbackT;
  QualType T;
  for (auto *E : UPD->expansions()) {
    QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
    if (ThisT.isNull())
      continue;
    else if (ThisT->getAs<UnresolvedUsingType>())
      FallbackT = ThisT;
    else if (T.isNull())
      T = ThisT;
    else
      assert(getSema().Context.hasSameType(ThisT, T) &&((getSema().Context.hasSameType(ThisT, T) && "mismatched resolved types in using pack expansion"
) ? static_cast<void> (0) : __assert_fail ("getSema().Context.hasSameType(ThisT, T) && \"mismatched resolved types in using pack expansion\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12937, __PRETTY_FUNCTION__))
             "mismatched resolved types in using pack expansion")((getSema().Context.hasSameType(ThisT, T) && "mismatched resolved types in using pack expansion"
) ? static_cast<void> (0) : __assert_fail ("getSema().Context.hasSameType(ThisT, T) && \"mismatched resolved types in using pack expansion\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12937, __PRETTY_FUNCTION__));
  }
  return T.isNull() ? FallbackT : T;
} else if (auto *Using = dyn_cast<UsingDecl>(D)) {
  assert(Using->hasTypename() &&((Using->hasTypename() && "UnresolvedUsingTypenameDecl transformed to non-typename using"
) ? static_cast<void> (0) : __assert_fail ("Using->hasTypename() && \"UnresolvedUsingTypenameDecl transformed to non-typename using\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12942, __PRETTY_FUNCTION__))
         "UnresolvedUsingTypenameDecl transformed to non-typename using")((Using->hasTypename() && "UnresolvedUsingTypenameDecl transformed to non-typename using"
) ? static_cast<void> (0) : __assert_fail ("Using->hasTypename() && \"UnresolvedUsingTypenameDecl transformed to non-typename using\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12942, __PRETTY_FUNCTION__));

  // A valid resolved using typename decl points to exactly one type decl.
  assert(++Using->shadow_begin() == Using->shadow_end())((++Using->shadow_begin() == Using->shadow_end()) ? static_cast
<void> (0) : __assert_fail ("++Using->shadow_begin() == Using->shadow_end()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12945, __PRETTY_FUNCTION__));
  Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
} else {
  assert(isa<UnresolvedUsingTypenameDecl>(D) &&((isa<UnresolvedUsingTypenameDecl>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"
) ? static_cast<void> (0) : __assert_fail ("isa<UnresolvedUsingTypenameDecl>(D) && \"UnresolvedUsingTypenameDecl transformed to non-using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12949, __PRETTY_FUNCTION__))
         "UnresolvedUsingTypenameDecl transformed to non-using decl")((isa<UnresolvedUsingTypenameDecl>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"
) ? static_cast<void> (0) : __assert_fail ("isa<UnresolvedUsingTypenameDecl>(D) && \"UnresolvedUsingTypenameDecl transformed to non-using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/Sema/TreeTransform.h"
, 12949, __PRETTY_FUNCTION__));
  Ty = cast<UnresolvedUsingTypenameDecl>(D);
}

return SemaRef.Context.getTypeDeclType(Ty);
12954}

12956template<typename Derived>
12957QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
                                                     SourceLocation Loc) {
return SemaRef.BuildTypeofExprType(E, Loc);
12960}

12962template<typename Derived>
12963QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
return SemaRef.Context.getTypeOfType(Underlying);
12965}

12967template<typename Derived>
12968QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
                                                   SourceLocation Loc) {
return SemaRef.BuildDecltypeType(E, Loc);
12971}

12973template<typename Derived>
12974QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
                                          UnaryTransformType::UTTKind UKind,
                                          SourceLocation Loc) {
return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
12978}

12980template<typename Derived>
12981QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
                                                    TemplateName Template,
                                           SourceLocation TemplateNameLoc,
                                   TemplateArgumentListInfo &TemplateArgs) {
return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
12986}

12988template<typename Derived>
12989QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
                                                 SourceLocation KWLoc) {
return SemaRef.BuildAtomicType(ValueType, KWLoc);
12992}

12994template<typename Derived>
12995QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
                                               SourceLocation KWLoc,
                                               bool isReadPipe) {
return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc)
                  : SemaRef.BuildWritePipeType(ValueType, KWLoc);
13000}

13002template<typename Derived>
13003TemplateName
13004TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          bool TemplateKW,
                                          TemplateDecl *Template) {
return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
                                                Template);
13009}

13011template<typename Derived>
13012TemplateName
13013TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          SourceLocation TemplateKWLoc,
                                          const IdentifierInfo &Name,
                                          SourceLocation NameLoc,
                                          QualType ObjectType,
                                          NamedDecl *FirstQualifierInScope,
                                          bool AllowInjectedClassName) {
UnqualifiedId TemplateName;
TemplateName.setIdentifier(&Name, NameLoc);
Sema::TemplateTy Template;
getSema().ActOnDependentTemplateName(/*Scope=*/nullptr,
                                     SS, TemplateKWLoc, TemplateName,
                                     ParsedType::make(ObjectType),
                                     /*EnteringContext=*/false,
                                     Template, AllowInjectedClassName);
return Template.get();
13029}

13031template<typename Derived>
13032TemplateName
13033TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          SourceLocation TemplateKWLoc,
                                          OverloadedOperatorKind Operator,
                                          SourceLocation NameLoc,
                                          QualType ObjectType,
                                          bool AllowInjectedClassName) {
UnqualifiedId Name;
// FIXME: Bogus location information.
SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
Sema::TemplateTy Template;
getSema().ActOnDependentTemplateName(/*Scope=*/nullptr,
                                     SS, TemplateKWLoc, Name,
                                     ParsedType::make(ObjectType),
                                     /*EnteringContext=*/false,
                                     Template, AllowInjectedClassName);
return Template.get();
13050}

13052template<typename Derived>
13053ExprResult
13054TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
                                                 SourceLocation OpLoc,
                                                 Expr *OrigCallee,
                                                 Expr *First,
                                                 Expr *Second) {
Expr *Callee = OrigCallee->IgnoreParenCasts();
bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);

if (First->getObjectKind() == OK_ObjCProperty) {
  BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
  if (BinaryOperator::isAssignmentOp(Opc))
    return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc,
                                               First, Second);
  ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
  if (Result.isInvalid())
    return ExprError();
  First = Result.get();
}

if (Second && Second->getObjectKind() == OK_ObjCProperty) {
  ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
  if (Result.isInvalid())
    return ExprError();
  Second = Result.get();
}

// Determine whether this should be a builtin operation.
if (Op == OO_Subscript) {
  if (!First->getType()->isOverloadableType() &&
      !Second->getType()->isOverloadableType())
    return getSema().CreateBuiltinArraySubscriptExpr(
        First, Callee->getBeginLoc(), Second, OpLoc);
} else if (Op == OO_Arrow) {
  // -> is never a builtin operation.
  return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
} else if (Second == nullptr || isPostIncDec) {
  if (!First->getType()->isOverloadableType() ||
      (Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) {
    // The argument is not of overloadable type, or this is an expression
    // of the form &Class::member, so try to create a built-in unary
    // operation.
    UnaryOperatorKind Opc
      = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);

    return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
  }
} else {
  if (!First->getType()->isOverloadableType() &&
      !Second->getType()->isOverloadableType()) {
    // Neither of the arguments is an overloadable type, so try to
    // create a built-in binary operation.
    BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
    ExprResult Result
      = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
    if (Result.isInvalid())
      return ExprError();

    return Result;
  }
}

// Compute the transformed set of functions (and function templates) to be
// used during overload resolution.
UnresolvedSet<16> Functions;
bool RequiresADL;

if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
  Functions.append(ULE->decls_begin(), ULE->decls_end());
  // If the overload could not be resolved in the template definition
  // (because we had a dependent argument), ADL is performed as part of
  // template instantiation.
  RequiresADL = ULE->requiresADL();
} else {
  // If we've resolved this to a particular non-member function, just call
  // that function. If we resolved it to a member function,
  // CreateOverloaded* will find that function for us.
  NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
  if (!isa<CXXMethodDecl>(ND))
    Functions.addDecl(ND);
  RequiresADL = false;
}

// Add any functions found via argument-dependent lookup.
Expr *Args[2] = { First, Second };
unsigned NumArgs = 1 + (Second != nullptr);

// Create the overloaded operator invocation for unary operators.
if (NumArgs == 1 || isPostIncDec) {
  UnaryOperatorKind Opc
    = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
  return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First,
                                         RequiresADL);
}

if (Op == OO_Subscript) {
  SourceLocation LBrace;
  SourceLocation RBrace;

  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
      DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
      LBrace = SourceLocation::getFromRawEncoding(
                  NameLoc.CXXOperatorName.BeginOpNameLoc);
      RBrace = SourceLocation::getFromRawEncoding(
                  NameLoc.CXXOperatorName.EndOpNameLoc);
  } else {
    LBrace = Callee->getBeginLoc();
    RBrace = OpLoc;
  }

  return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
                                                    First, Second);
}

// Create the overloaded operator invocation for binary operators.
BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
ExprResult Result = SemaRef.CreateOverloadedBinOp(
    OpLoc, Opc, Functions, Args[0], Args[1], RequiresADL);
if (Result.isInvalid())
  return ExprError();

return Result;
13175}

13177template<typename Derived>
13178ExprResult
13179TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
                                                   SourceLocation OperatorLoc,
                                                     bool isArrow,
                                                     CXXScopeSpec &SS,
                                                   TypeSourceInfo *ScopeType,
                                                     SourceLocation CCLoc,
                                                     SourceLocation TildeLoc,
                                      PseudoDestructorTypeStorage Destroyed) {
QualType BaseType = Base->getType();
if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
    (!isArrow && !BaseType->getAs<RecordType>()) ||
    (isArrow && BaseType->getAs<PointerType>() &&
     !BaseType->getAs<PointerType>()->getPointeeType()
                                            ->template getAs<RecordType>())){
  // This pseudo-destructor expression is still a pseudo-destructor.
  return SemaRef.BuildPseudoDestructorExpr(
      Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
      CCLoc, TildeLoc, Destroyed);
}

TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
               SemaRef.Context.getCanonicalType(DestroyedType->getType())));
DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
NameInfo.setNamedTypeInfo(DestroyedType);

// The scope type is now known to be a valid nested name specifier
// component. Tack it on to the end of the nested name specifier.
if (ScopeType) {
  if (!ScopeType->getType()->getAs<TagType>()) {
    getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
                   diag::err_expected_class_or_namespace)
        << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
    return ExprError();
  }
  SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
            CCLoc);
}

SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
return getSema().BuildMemberReferenceExpr(Base, BaseType,
                                          OperatorLoc, isArrow,
                                          SS, TemplateKWLoc,
                                          /*FIXME: FirstQualifier*/ nullptr,
                                          NameInfo,
                                          /*TemplateArgs*/ nullptr,
                                          /*S*/nullptr);
13226}

13228template<typename Derived>
13229StmtResult
13230TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
SourceLocation Loc = S->getBeginLoc();
CapturedDecl *CD = S->getCapturedDecl();
unsigned NumParams = CD->getNumParams();
unsigned ContextParamPos = CD->getContextParamPosition();
SmallVector<Sema::CapturedParamNameType, 4> Params;
for (unsigned I = 0; I < NumParams; ++I) {
  if (I != ContextParamPos) {
    Params.push_back(
           std::make_pair(
                CD->getParam(I)->getName(),
                getDerived().TransformType(CD->getParam(I)->getType())));
  } else {
    Params.push_back(std::make_pair(StringRef(), QualType()));
  }
}
getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
                                   S->getCapturedRegionKind(), Params);
StmtResult Body;
{
  Sema::CompoundScopeRAII CompoundScope(getSema());
  Body = getDerived().TransformStmt(S->getCapturedStmt());
}

if (Body.isInvalid()) {
  getSema().ActOnCapturedRegionError();
  return StmtError();
}

return getSema().ActOnCapturedRegionEnd(Body.get());
13260}

13262} // end namespace clang

13264#endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H

←

/build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/include/clang/AST/TypeNodes.inc

→

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|*                                                                            *|
3|* An x-macro database of Clang type nodes                                    *|
4|*                                                                            *|
5|* Automatically generated file, do not edit!                                 *|
6|*                                                                            *|
7\*===----------------------------------------------------------------------===*/
8 
9#ifndef ABSTRACT_TYPE
10#  define ABSTRACT_TYPE(Class, Base) TYPE(Class, Base)
11#endif
12#ifndef NON_CANONICAL_TYPE
13#  define NON_CANONICAL_TYPE(Class, Base) TYPE(Class, Base)
14#endif
15#ifndef DEPENDENT_TYPE
16#  define DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
17#endif
18#ifndef NON_CANONICAL_UNLESS_DEPENDENT_TYPE
19#  define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) TYPE(Class, Base)
20#endif
21NON_CANONICAL_TYPE(Adjusted, Type)
22ABSTRACT_TYPE(Array, Type)
23TYPE(Atomic, Type)
24NON_CANONICAL_TYPE(Attributed, Type)
25TYPE(Auto, DeducedType)
26TYPE(BlockPointer, Type)
27TYPE(Builtin, Type)
28TYPE(Complex, Type)
29TYPE(ConstantArray, ArrayType)
30NON_CANONICAL_TYPE(Decayed, AdjustedType)
31NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Decltype, Type)
32TYPE(DeducedTemplateSpecialization, DeducedType)
33ABSTRACT_TYPE(Deduced, Type)
34DEPENDENT_TYPE(DependentAddressSpace, Type)
35DEPENDENT_TYPE(DependentName, Type)
36DEPENDENT_TYPE(DependentSizedArray, ArrayType)
37DEPENDENT_TYPE(DependentSizedExtVector, Type)
38DEPENDENT_TYPE(DependentTemplateSpecialization, Type)
39DEPENDENT_TYPE(DependentVector, Type)
40NON_CANONICAL_TYPE(Elaborated, Type)
41TYPE(Enum, TagType)
42TYPE(ExtVector, VectorType)
43TYPE(FunctionNoProto, FunctionType)
44TYPE(FunctionProto, FunctionType)
45ABSTRACT_TYPE(Function, Type)
46TYPE(IncompleteArray, ArrayType)
47DEPENDENT_TYPE(InjectedClassName, Type)
48TYPE(LValueReference, ReferenceType)
49NON_CANONICAL_TYPE(MacroQualified, Type)
50TYPE(MemberPointer, Type)
51TYPE(ObjCInterface, ObjCObjectType)
52TYPE(ObjCObjectPointer, Type)
53TYPE(ObjCObject, Type)
54NON_CANONICAL_TYPE(ObjCTypeParam, Type)
55NON_CANONICAL_UNLESS_DEPENDENT_TYPE(PackExpansion, Type)
56NON_CANONICAL_TYPE(Paren, Type)
57TYPE(Pipe, Type)
58TYPE(Pointer, Type)
59TYPE(RValueReference, ReferenceType)
6
←
Calling 'TreeTransform::TransformRValueReferenceType'→
60TYPE(Record, TagType)
61ABSTRACT_TYPE(Reference, Type)
62DEPENDENT_TYPE(SubstTemplateTypeParmPack, Type)
63NON_CANONICAL_TYPE(SubstTemplateTypeParm, Type)
64ABSTRACT_TYPE(Tag, Type)
65NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TemplateSpecialization, Type)
66DEPENDENT_TYPE(TemplateTypeParm, Type)
67NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOfExpr, Type)
68NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOf, Type)
69NON_CANONICAL_TYPE(Typedef, Type)
70NON_CANONICAL_UNLESS_DEPENDENT_TYPE(UnaryTransform, Type)
71DEPENDENT_TYPE(UnresolvedUsing, Type)
72TYPE(VariableArray, ArrayType)
3
←
Calling 'TreeTransform::TransformVariableArrayType'→
73TYPE(Vector, Type)
74#ifdef LAST_TYPE
75LAST_TYPE(Vector)
76#undef LAST_TYPE
77#endif
78#ifdef LEAF_TYPE
79LEAF_TYPE(Builtin)
80LEAF_TYPE(Enum)
81LEAF_TYPE(InjectedClassName)
82LEAF_TYPE(ObjCInterface)
83LEAF_TYPE(Record)
84LEAF_TYPE(TemplateTypeParm)
85#undef LEAF_TYPE
86#endif
87#undef TYPE
88#undef ABSTRACT_TYPE
89#undef ABSTRACT_TYPE
90#undef NON_CANONICAL_TYPE
91#undef DEPENDENT_TYPE
92#undef NON_CANONICAL_UNLESS_DEPENDENT_TYPE

←

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h

→

1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H

20#include "clang/AST/NestedNameSpecifier.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/Basic/AddressSpaces.h"
23#include "clang/Basic/AttrKinds.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/ExceptionSpecificationType.h"
26#include "clang/Basic/LLVM.h"
27#include "clang/Basic/Linkage.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/SourceLocation.h"
30#include "clang/Basic/Specifiers.h"
31#include "clang/Basic/Visibility.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/ADT/APSInt.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/None.h"
37#include "llvm/ADT/Optional.h"
38#include "llvm/ADT/PointerIntPair.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/StringRef.h"
41#include "llvm/ADT/Twine.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/PointerLikeTypeTraits.h"
47#include "llvm/Support/type_traits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <cstring>
53#include <string>
54#include <type_traits>
55#include <utility>

57namespace clang {

59class ExtQuals;
60class QualType;
61class TagDecl;
62class Type;

64enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
67};

69} // namespace clang

71namespace llvm {

template <typename T>
struct PointerLikeTypeTraits;
template<>
struct PointerLikeTypeTraits< ::clang::Type*> {
  static inline void *getAsVoidPointer(::clang::Type *P) { return P; }

  static inline ::clang::Type *getFromVoidPointer(void *P) {
    return static_cast< ::clang::Type*>(P);
  }

  enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
};

template<>
struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
  static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }

  static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
    return static_cast< ::clang::ExtQuals*>(P);
  }

  enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
};

97} // namespace llvm

99namespace clang {

101class ASTContext;
102template <typename> class CanQual;
103class CXXRecordDecl;
104class DeclContext;
105class EnumDecl;
106class Expr;
107class ExtQualsTypeCommonBase;
108class FunctionDecl;
109class IdentifierInfo;
110class NamedDecl;
111class ObjCInterfaceDecl;
112class ObjCProtocolDecl;
113class ObjCTypeParamDecl;
114struct PrintingPolicy;
115class RecordDecl;
116class Stmt;
117class TagDecl;
118class TemplateArgument;
119class TemplateArgumentListInfo;
120class TemplateArgumentLoc;
121class TemplateTypeParmDecl;
122class TypedefNameDecl;
123class UnresolvedUsingTypenameDecl;

125using CanQualType = CanQual<Type>;

127// Provide forward declarations for all of the *Type classes.
128#define TYPE(Class, Base) class Class##Type;
129#include "clang/AST/TypeNodes.inc"

131/// The collection of all-type qualifiers we support.
132/// Clang supports five independent qualifiers:
133/// * C99: const, volatile, and restrict
134/// * MS: __unaligned
135/// * Embedded C (TR18037): address spaces
136/// * Objective C: the GC attributes (none, weak, or strong)
137class Qualifiers {
138public:
enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
  Const    = 0x1,
  Restrict = 0x2,
  Volatile = 0x4,
  CVRMask = Const | Volatile | Restrict
};

enum GC {
  GCNone = 0,
  Weak,
  Strong
};

enum ObjCLifetime {
  /// There is no lifetime qualification on this type.
  OCL_None,

  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,

  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,

  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,

  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing
};

enum {
  /// The maximum supported address space number.
  /// 23 bits should be enough for anyone.
  MaxAddressSpace = 0x7fffffu,

  /// The width of the "fast" qualifier mask.
  FastWidth = 3,

  /// The fast qualifier mask.
  FastMask = (1 << FastWidth) - 1
};

/// Returns the common set of qualifiers while removing them from
/// the given sets.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
  // If both are only CVR-qualified, bit operations are sufficient.
  if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
    Qualifiers Q;
    Q.Mask = L.Mask & R.Mask;
    L.Mask &= ~Q.Mask;
    R.Mask &= ~Q.Mask;
    return Q;
  }

  Qualifiers Q;
  unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
  Q.addCVRQualifiers(CommonCRV);
  L.removeCVRQualifiers(CommonCRV);
  R.removeCVRQualifiers(CommonCRV);

  if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
    Q.setObjCGCAttr(L.getObjCGCAttr());
    L.removeObjCGCAttr();
    R.removeObjCGCAttr();
  }

  if (L.getObjCLifetime() == R.getObjCLifetime()) {
    Q.setObjCLifetime(L.getObjCLifetime());
    L.removeObjCLifetime();
    R.removeObjCLifetime();
  }

  if (L.getAddressSpace() == R.getAddressSpace()) {
    Q.setAddressSpace(L.getAddressSpace());
    L.removeAddressSpace();
    R.removeAddressSpace();
  }
  return Q;
}

static Qualifiers fromFastMask(unsigned Mask) {
  Qualifiers Qs;
  Qs.addFastQualifiers(Mask);
  return Qs;
}

static Qualifiers fromCVRMask(unsigned CVR) {
  Qualifiers Qs;
  Qs.addCVRQualifiers(CVR);
  return Qs;
}

static Qualifiers fromCVRUMask(unsigned CVRU) {
  Qualifiers Qs;
  Qs.addCVRUQualifiers(CVRU);
  return Qs;
}

// Deserialize qualifiers from an opaque representation.
static Qualifiers fromOpaqueValue(unsigned opaque) {
  Qualifiers Qs;
  Qs.Mask = opaque;
  return Qs;
}

// Serialize these qualifiers into an opaque representation.
unsigned getAsOpaqueValue() const {
  return Mask;
}

bool hasConst() const { return Mask & Const; }
bool hasOnlyConst() const { return Mask == Const; }
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
bool hasOnlyVolatile() const { return Mask == Volatile; }
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
bool hasOnlyRestrict() const { return Mask == Restrict; }
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }

void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 274, __PRETTY_FUNCTION__));
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 278, __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 285, __PRETTY_FUNCTION__));
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 289, __PRETTY_FUNCTION__));
  Mask |= mask;
}

bool hasUnaligned() const { return Mask & UMask; }
void setUnaligned(bool flag) {
  Mask = (Mask & ~UMask) | (flag ? UMask : 0);
}
void removeUnaligned() { Mask &= ~UMask; }
void addUnaligned() { Mask |= UMask; }

bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
void setObjCGCAttr(GC type) {
  Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
}
void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
void addObjCGCAttr(GC type) {
  assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 307, __PRETTY_FUNCTION__));
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  return qs;
}
Qualifiers withoutAddressSpace() const {
  Qualifiers qs = *this;
  qs.removeAddressSpace();
  return qs;
}

bool hasObjCLifetime() const { return Mask & LifetimeMask; }
ObjCLifetime getObjCLifetime() const {
  return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
}
void setObjCLifetime(ObjCLifetime type) {
  Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
}
void removeObjCLifetime() { setObjCLifetime(OCL_None); }
void addObjCLifetime(ObjCLifetime type) {
  assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 335, __PRETTY_FUNCTION__));
  assert(!hasObjCLifetime())((!hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 336, __PRETTY_FUNCTION__));
  Mask |= (type << LifetimeShift);
}

/// True if the lifetime is neither None or ExplicitNone.
bool hasNonTrivialObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime > OCL_ExplicitNone);
}

/// True if the lifetime is either strong or weak.
bool hasStrongOrWeakObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime == OCL_Strong || lifetime == OCL_Weak);
}

bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
LangAS getAddressSpace() const {
  return static_cast<LangAS>(Mask >> AddressSpaceShift);
}
bool hasTargetSpecificAddressSpace() const {
  return isTargetAddressSpace(getAddressSpace());
}
/// Get the address space attribute value to be printed by diagnostics.
unsigned getAddressSpaceAttributePrintValue() const {
  auto Addr = getAddressSpace();
  // This function is not supposed to be used with language specific
  // address spaces. If that happens, the diagnostic message should consider
  // printing the QualType instead of the address space value.
  assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((Addr == LangAS::Default || hasTargetSpecificAddressSpace())
 ? static_cast<void> (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 365, __PRETTY_FUNCTION__));
  if (Addr != LangAS::Default)
    return toTargetAddressSpace(Addr);
  // TODO: The diagnostic messages where Addr may be 0 should be fixed
  // since it cannot differentiate the situation where 0 denotes the default
  // address space or user specified __attribute__((address_space(0))).
  return 0;
}
void setAddressSpace(LangAS space) {
  assert((unsigned)space <= MaxAddressSpace)(((unsigned)space <= MaxAddressSpace) ? static_cast<void
> (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 374, __PRETTY_FUNCTION__));
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((space != LangAS::Default) ? static_cast<void> (0) : __assert_fail
 ("space != LangAS::Default", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 380, __PRETTY_FUNCTION__));
  setAddressSpace(space);
}

// Fast qualifiers are those that can be allocated directly
// on a QualType object.
bool hasFastQualifiers() const { return getFastQualifiers(); }
unsigned getFastQualifiers() const { return Mask & FastMask; }
void setFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 389, __PRETTY_FUNCTION__));
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 393, __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 400, __PRETTY_FUNCTION__));
  Mask |= mask;
}

/// Return true if the set contains any qualifiers which require an ExtQuals
/// node to be allocated.
bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
Qualifiers getNonFastQualifiers() const {
  Qualifiers Quals = *this;
  Quals.setFastQualifiers(0);
  return Quals;
}

/// Return true if the set contains any qualifiers.
bool hasQualifiers() const { return Mask; }
bool empty() const { return !Mask; }

/// Add the qualifiers from the given set to this set.
void addQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-or it in.
  if (!(Q.Mask & ~CVRMask))
    Mask |= Q.Mask;
  else {
    Mask |= (Q.Mask & CVRMask);
    if (Q.hasAddressSpace())
      addAddressSpace(Q.getAddressSpace());
    if (Q.hasObjCGCAttr())
      addObjCGCAttr(Q.getObjCGCAttr());
    if (Q.hasObjCLifetime())
      addObjCLifetime(Q.getObjCLifetime());
  }
}

/// Remove the qualifiers from the given set from this set.
void removeQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-and the inverse in.
  if (!(Q.Mask & ~CVRMask))
    Mask &= ~Q.Mask;
  else {
    Mask &= ~(Q.Mask & CVRMask);
    if (getObjCGCAttr() == Q.getObjCGCAttr())
      removeObjCGCAttr();
    if (getObjCLifetime() == Q.getObjCLifetime())
      removeObjCLifetime();
    if (getAddressSpace() == Q.getAddressSpace())
      removeAddressSpace();
  }
}

/// Add the qualifiers from the given set to this set, given that
/// they don't conflict.
void addConsistentQualifiers(Qualifiers qs) {
  assert(getAddressSpace() == qs.getAddressSpace() ||((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
 ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 455, __PRETTY_FUNCTION__))
         !hasAddressSpace() || !qs.hasAddressSpace())((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
 ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 455, __PRETTY_FUNCTION__));
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
 !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 457, __PRETTY_FUNCTION__))
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
 !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 457, __PRETTY_FUNCTION__));
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 459, __PRETTY_FUNCTION__))
         !hasObjCLifetime() || !qs.hasObjCLifetime())((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 459, __PRETTY_FUNCTION__));
  Mask |= qs.Mask;
}

/// Returns true if address space A is equal to or a superset of B.
/// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
/// overlapping address spaces.
/// CL1.1 or CL1.2:
///   every address space is a superset of itself.
/// CL2.0 adds:
///   __generic is a superset of any address space except for __constant.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
  // Address spaces must match exactly.
  return A == B ||
         // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
         // for __constant can be used as __generic.
         (A == LangAS::opencl_generic && B != LangAS::opencl_constant);
}

/// Returns true if the address space in these qualifiers is equal to or
/// a superset of the address space in the argument qualifiers.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
}

/// Determines if these qualifiers compatibly include another set.
/// Generally this answers the question of whether an object with the other
/// qualifiers can be safely used as an object with these qualifiers.
bool compatiblyIncludes(Qualifiers other) const {
  return isAddressSpaceSupersetOf(other) &&
         // ObjC GC qualifiers can match, be added, or be removed, but can't
         // be changed.
         (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
          !other.hasObjCGCAttr()) &&
         // ObjC lifetime qualifiers must match exactly.
         getObjCLifetime() == other.getObjCLifetime() &&
         // CVR qualifiers may subset.
         (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
         // U qualifier may superset.
         (!other.hasUnaligned() || hasUnaligned());
}

/// Determines if these qualifiers compatibly include another set of
/// qualifiers from the narrow perspective of Objective-C ARC lifetime.
///
/// One set of Objective-C lifetime qualifiers compatibly includes the other
/// if the lifetime qualifiers match, or if both are non-__weak and the
/// including set also contains the 'const' qualifier, or both are non-__weak
/// and one is None (which can only happen in non-ARC modes).
bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
  if (getObjCLifetime() == other.getObjCLifetime())
    return true;

  if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
    return false;

  if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
    return true;

  return hasConst();
}

/// Determine whether this set of qualifiers is a strict superset of
/// another set of qualifiers, not considering qualifier compatibility.
bool isStrictSupersetOf(Qualifiers Other) const;

bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }

explicit operator bool() const { return hasQualifiers(); }

Qualifiers &operator+=(Qualifiers R) {
  addQualifiers(R);
  return *this;
}

// Union two qualifier sets.  If an enumerated qualifier appears
// in both sets, use the one from the right.
friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
  L += R;
  return L;
}

Qualifiers &operator-=(Qualifiers R) {
  removeQualifiers(R);
  return *this;
}

/// Compute the difference between two qualifier sets.
friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
  L -= R;
  return L;
}

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
void print(raw_ostream &OS, const PrintingPolicy &Policy,
           bool appendSpaceIfNonEmpty = false) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddInteger(Mask);
}

564private:
// bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
//           |C R V|U|GCAttr|Lifetime|AddressSpace|
uint32_t Mask = 0;

static const uint32_t UMask = 0x8;
static const uint32_t UShift = 3;
static const uint32_t GCAttrMask = 0x30;
static const uint32_t GCAttrShift = 4;
static const uint32_t LifetimeMask = 0x1C0;
static const uint32_t LifetimeShift = 6;
static const uint32_t AddressSpaceMask =
    ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
static const uint32_t AddressSpaceShift = 9;
578};

580/// A std::pair-like structure for storing a qualified type split
581/// into its local qualifiers and its locally-unqualified type.
582struct SplitQualType {
/// The locally-unqualified type.
const Type *Ty = nullptr;

/// The local qualifiers.
Qualifiers Quals;

SplitQualType() = default;
SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}

SplitQualType getSingleStepDesugaredType() const; // end of this file

// Make std::tie work.
std::pair<const Type *,Qualifiers> asPair() const {
  return std::pair<const Type *, Qualifiers>(Ty, Quals);
}

friend bool operator==(SplitQualType a, SplitQualType b) {
  return a.Ty == b.Ty && a.Quals == b.Quals;
}
friend bool operator!=(SplitQualType a, SplitQualType b) {
  return a.Ty != b.Ty || a.Quals != b.Quals;
}
605};

607/// The kind of type we are substituting Objective-C type arguments into.
608///
609/// The kind of substitution affects the replacement of type parameters when
610/// no concrete type information is provided, e.g., when dealing with an
611/// unspecialized type.
612enum class ObjCSubstitutionContext {
/// An ordinary type.
Ordinary,

/// The result type of a method or function.
Result,

/// The parameter type of a method or function.
Parameter,

/// The type of a property.
Property,

/// The superclass of a type.
Superclass,
627};

629/// A (possibly-)qualified type.
630///
631/// For efficiency, we don't store CV-qualified types as nodes on their
632/// own: instead each reference to a type stores the qualifiers.  This
633/// greatly reduces the number of nodes we need to allocate for types (for
634/// example we only need one for 'int', 'const int', 'volatile int',
635/// 'const volatile int', etc).
636///
637/// As an added efficiency bonus, instead of making this a pair, we
638/// just store the two bits we care about in the low bits of the
639/// pointer.  To handle the packing/unpacking, we make QualType be a
640/// simple wrapper class that acts like a smart pointer.  A third bit
641/// indicates whether there are extended qualifiers present, in which
642/// case the pointer points to a special structure.
643class QualType {
friend class QualifierCollector;

// Thankfully, these are efficiently composable.
llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
                     Qualifiers::FastWidth> Value;

const ExtQuals *getExtQualsUnsafe() const {
  return Value.getPointer().get<const ExtQuals*>();
}

const Type *getTypePtrUnsafe() const {
  return Value.getPointer().get<const Type*>();
}

const ExtQualsTypeCommonBase *getCommonPtr() const {
  assert(!isNull() && "Cannot retrieve a NULL type pointer")((!isNull() && "Cannot retrieve a NULL type pointer")
 ? static_cast<void> (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 659, __PRETTY_FUNCTION__));
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

665public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }

/// Retrieves a pointer to the underlying (unqualified) type.
///
/// This function requires that the type not be NULL. If the type might be
/// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
const Type *getTypePtr() const;

const Type *getTypePtrOrNull() const;

/// Retrieves a pointer to the name of the base type.
const IdentifierInfo *getBaseTypeIdentifier() const;

/// Divides a QualType into its unqualified type and a set of local
/// qualifiers.
SplitQualType split() const;

void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }

static QualType getFromOpaquePtr(const void *Ptr) {
  QualType T;
  T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
  return T;
}

const Type &operator*() const {
  return *getTypePtr();
}

const Type *operator->() const {
  return getTypePtr();
}

bool isCanonical() const;
bool isCanonicalAsParam() const;

/// Return true if this QualType doesn't point to a type yet.
bool isNull() const {
  return Value.getPointer().isNull();
9
←
Calling 'PointerUnion::isNull'→
12
←
Returning from 'PointerUnion::isNull'→
13
←
Returning zero, which participates in a condition later→
}

/// Determine whether this particular QualType instance has the
/// "const" qualifier set, without looking through typedefs that may have
/// added "const" at a different level.
bool isLocalConstQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Const);
}

/// Determine whether this type is const-qualified.
bool isConstQualified() const;

/// Determine whether this particular QualType instance has the
/// "restrict" qualifier set, without looking through typedefs that may have
/// added "restrict" at a different level.
bool isLocalRestrictQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Restrict);
}

/// Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// Determine whether this particular QualType instance has the
/// "volatile" qualifier set, without looking through typedefs that may have
/// added "volatile" at a different level.
bool isLocalVolatileQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Volatile);
}

/// Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// Determine whether this particular QualType instance has any
/// qualifiers, without looking through any typedefs that might add
/// qualifiers at a different level.
bool hasLocalQualifiers() const {
  return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
}

/// Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// Determine whether this particular QualType instance has any
/// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
/// instance.
bool hasLocalNonFastQualifiers() const {
  return Value.getPointer().is<const ExtQuals*>();
}

/// Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// local to this particular QualType instance, not including any qualifiers
/// acquired through typedefs or other sugar.
unsigned getLocalCVRQualifiers() const {
  return getLocalFastQualifiers();
}

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// applied to this type.
unsigned getCVRQualifiers() const;

bool isConstant(const ASTContext& Ctx) const {
  return QualType::isConstant(*this, Ctx);
}

/// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isPODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the rules of the C++98
/// standard, regardless of the current compilation's language.
bool isCXX98PODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the more relaxed rules
/// of the C++11 standard, regardless of the current compilation's language.
/// (C++0x [basic.types]p9). Note that, unlike
/// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
bool isCXX11PODType(const ASTContext &Context) const;

/// Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isTrivialType(const ASTContext &Context) const;

/// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTriviallyCopyableType(const ASTContext &Context) const;


/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;

/// Returns true if it is not a class or if the class might not be dynamic.
bool mayBeNotDynamicClass() const;

// Don't promise in the API that anything besides 'const' can be
// easily added.

/// Add the `const` type qualifier to this QualType.
void addConst() {
  addFastQualifiers(Qualifiers::Const);
}
QualType withConst() const {
  return withFastQualifiers(Qualifiers::Const);
}

/// Add the `volatile` type qualifier to this QualType.
void addVolatile() {
  addFastQualifiers(Qualifiers::Volatile);
}
QualType withVolatile() const {
  return withFastQualifiers(Qualifiers::Volatile);
}

/// Add the `restrict` qualifier to this QualType.
void addRestrict() {
  addFastQualifiers(Qualifiers::Restrict);
}
QualType withRestrict() const {
  return withFastQualifiers(Qualifiers::Restrict);
}

QualType withCVRQualifiers(unsigned CVR) const {
  return withFastQualifiers(CVR);
}

void addFastQualifiers(unsigned TQs) {
  assert(!(TQs & ~Qualifiers::FastMask)((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 841, __PRETTY_FUNCTION__))
         && "non-fast qualifier bits set in mask!")((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 841, __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() | TQs);
}

void removeLocalConst();
void removeLocalVolatile();
void removeLocalRestrict();
void removeLocalCVRQualifiers(unsigned Mask);

void removeLocalFastQualifiers() { Value.setInt(0); }
void removeLocalFastQualifiers(unsigned Mask) {
  assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 852, __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() & ~Mask);
}

// Creates a type with the given qualifiers in addition to any
// qualifiers already on this type.
QualType withFastQualifiers(unsigned TQs) const {
  QualType T = *this;
  T.addFastQualifiers(TQs);
  return T;
}

// Creates a type with exactly the given fast qualifiers, removing
// any existing fast qualifiers.
QualType withExactLocalFastQualifiers(unsigned TQs) const {
  return withoutLocalFastQualifiers().withFastQualifiers(TQs);
}

// Removes fast qualifiers, but leaves any extended qualifiers in place.
QualType withoutLocalFastQualifiers() const {
  QualType T = *this;
  T.removeLocalFastQualifiers();
  return T;
}

QualType getCanonicalType() const;

/// Return this type with all of the instance-specific qualifiers
/// removed, but without removing any qualifiers that may have been applied
/// through typedefs.
QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }

/// Retrieve the unqualified variant of the given type,
/// removing as little sugar as possible.
///
/// This routine looks through various kinds of sugar to find the
/// least-desugared type that is unqualified. For example, given:
///
/// \code
/// typedef int Integer;
/// typedef const Integer CInteger;
/// typedef CInteger DifferenceType;
/// \endcode
///
/// Executing \c getUnqualifiedType() on the type \c DifferenceType will
/// desugar until we hit the type \c Integer, which has no qualifiers on it.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline QualType getUnqualifiedType() const;

/// Retrieve the unqualified variant of the given type, removing as little
/// sugar as possible.
///
/// Like getUnqualifiedType(), but also returns the set of
/// qualifiers that were built up.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline SplitQualType getSplitUnqualifiedType() const;

/// Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// Determine whether this type is at least as qualified as the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isAtLeastAsQualifiedAs(QualType Other) const;

QualType getNonReferenceType() const;

/// Determine the type of a (typically non-lvalue) expression with the
/// specified result type.
///
/// This routine should be used for expressions for which the return type is
/// explicitly specified (e.g., in a cast or call) and isn't necessarily
/// an lvalue. It removes a top-level reference (since there are no
/// expressions of reference type) and deletes top-level cvr-qualifiers
/// from non-class types (in C++) or all types (in C).
QualType getNonLValueExprType(const ASTContext &Context) const;

/// Return the specified type with any "sugar" removed from
/// the type.  This takes off typedefs, typeof's etc.  If the outer level of
/// the type is already concrete, it returns it unmodified.  This is similar
/// to getting the canonical type, but it doesn't remove *all* typedefs.  For
/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
/// concrete.
///
/// Qualifiers are left in place.
QualType getDesugaredType(const ASTContext &Context) const {
  return getDesugaredType(*this, Context);
}

SplitQualType getSplitDesugaredType() const {
  return getSplitDesugaredType(*this);
}

/// Return the specified type with one level of "sugar" removed from
/// the type.
///
/// This routine takes off the first typedef, typeof, etc. If the outer level
/// of the type is already concrete, it returns it unmodified.
QualType getSingleStepDesugaredType(const ASTContext &Context) const {
  return getSingleStepDesugaredTypeImpl(*this, Context);
}

/// Returns the specified type after dropping any
/// outer-level parentheses.
QualType IgnoreParens() const {
  if (isa<ParenType>(*this))
    return QualType::IgnoreParens(*this);
  return *this;
}

/// Indicate whether the specified types and qualifiers are identical.
friend bool operator==(const QualType &LHS, const QualType &RHS) {
  return LHS.Value == RHS.Value;
}
friend bool operator!=(const QualType &LHS, const QualType &RHS) {
  return LHS.Value != RHS.Value;
}
friend bool operator<(const QualType &LHS, const QualType &RHS) {
  return LHS.Value < RHS.Value;
}

static std::string getAsString(SplitQualType split,
                               const PrintingPolicy &Policy) {
  return getAsString(split.Ty, split.Quals, Policy);
}
static std::string getAsString(const Type *ty, Qualifiers qs,
                               const PrintingPolicy &Policy);

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

void print(raw_ostream &OS, const PrintingPolicy &Policy,
           const Twine &PlaceHolder = Twine(),
           unsigned Indentation = 0) const;

static void print(SplitQualType split, raw_ostream &OS,
                  const PrintingPolicy &policy, const Twine &PlaceHolder,
                  unsigned Indentation = 0) {
  return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
}

static void print(const Type *ty, Qualifiers qs,
                  raw_ostream &OS, const PrintingPolicy &policy,
                  const Twine &PlaceHolder,
                  unsigned Indentation = 0);

void getAsStringInternal(std::string &Str,
                         const PrintingPolicy &Policy) const;

static void getAsStringInternal(SplitQualType split, std::string &out,
                                const PrintingPolicy &policy) {
  return getAsStringInternal(split.Ty, split.Quals, out, policy);
}

static void getAsStringInternal(const Type *ty, Qualifiers qs,
                                std::string &out,
                                const PrintingPolicy &policy);

class StreamedQualTypeHelper {
  const QualType &T;
  const PrintingPolicy &Policy;
  const Twine &PlaceHolder;
  unsigned Indentation;

public:
  StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
                         const Twine &PlaceHolder, unsigned Indentation)
      : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
        Indentation(Indentation) {}

  friend raw_ostream &operator<<(raw_ostream &OS,
                                 const StreamedQualTypeHelper &SQT) {
    SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
    return OS;
  }
};

StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
                              const Twine &PlaceHolder = Twine(),
                              unsigned Indentation = 0) const {
  return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
}

void dump(const char *s) const;
void dump() const;
void dump(llvm::raw_ostream &OS) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddPointer(getAsOpaquePtr());
}

/// Return the address space of this type.
inline LangAS getAddressSpace() const;

/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;

/// true when Type is objc's weak.
bool isObjCGCWeak() const {
  return getObjCGCAttr() == Qualifiers::Weak;
}

/// true when Type is objc's strong.
bool isObjCGCStrong() const {
  return getObjCGCAttr() == Qualifiers::Strong;
}

/// Returns lifetime attribute of this type.
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return getQualifiers().getObjCLifetime();
}

bool hasNonTrivialObjCLifetime() const {
  return getQualifiers().hasNonTrivialObjCLifetime();
}

bool hasStrongOrWeakObjCLifetime() const {
  return getQualifiers().hasStrongOrWeakObjCLifetime();
}

// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;

enum PrimitiveDefaultInitializeKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,

  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct
};

/// Functions to query basic properties of non-trivial C struct types.

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to default initialize
/// and return the kind.
PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const;

enum PrimitiveCopyKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,

  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,

  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct
};

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to copy and return the
/// kind.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to destructively
/// move and return the kind. Destructive move in this context is a C++-style
/// move in which the source object is placed in a valid but unspecified state
/// after it is moved, as opposed to a truly destructive move in which the
/// source object is placed in an uninitialized state.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;

enum DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct
};

/// Returns a nonzero value if objects of this type require
/// non-trivial work to clean up after.  Non-zero because it's
/// conceivable that qualifiers (objc_gc(weak)?) could make
/// something require destruction.
DestructionKind isDestructedType() const {
  return isDestructedTypeImpl(*this);
}

/// Check if this is or contains a C union that is non-trivial to
/// default-initialize, which is a union that has a member that is non-trivial
/// to default-initialize. If this returns true,
/// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;

/// Check if this is or contains a C union that is non-trivial to destruct,
/// which is a union that has a member that is non-trivial to destruct. If
/// this returns true, isDestructedType returns DK_nontrivial_c_struct.
bool hasNonTrivialToPrimitiveDestructCUnion() const;

/// Check if this is or contains a C union that is non-trivial to copy, which
/// is a union that has a member that is non-trivial to copy. If this returns
/// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
bool hasNonTrivialToPrimitiveCopyCUnion() const;

/// Determine whether expressions of the given type are forbidden
/// from being lvalues in C.
///
/// The expression types that are forbidden to be lvalues are:
///   - 'void', but not qualified void
///   - function types
///
/// The exact rule here is C99 6.3.2.1:
///   An lvalue is an expression with an object type or an incomplete
///   type other than void.
bool isCForbiddenLValueType() const;

/// Substitute type arguments for the Objective-C type parameters used in the
/// subject type.
///
/// \param ctx ASTContext in which the type exists.
///
/// \param typeArgs The type arguments that will be substituted for the
/// Objective-C type parameters in the subject type, which are generally
/// computed via \c Type::getObjCSubstitutions. If empty, the type
/// parameters will be replaced with their bounds or id/Class, as appropriate
/// for the context.
///
/// \param context The context in which the subject type was written.
///
/// \returns the resulting type.
QualType substObjCTypeArgs(ASTContext &ctx,
                           ArrayRef<QualType> typeArgs,
                           ObjCSubstitutionContext context) const;

/// Substitute type arguments from an object type for the Objective-C type
/// parameters used in the subject type.
///
/// This operation combines the computation of type arguments for
/// substitution (\c Type::getObjCSubstitutions) with the actual process of
/// substitution (\c QualType::substObjCTypeArgs) for the convenience of
/// callers that need to perform a single substitution in isolation.
///
/// \param objectType The type of the object whose member type we're
/// substituting into. For example, this might be the receiver of a message
/// or the base of a property access.
///
/// \param dc The declaration context from which the subject type was
/// retrieved, which indicates (for example) which type parameters should
/// be substituted.
///
/// \param context The context in which the subject type was written.
///
/// \returns the subject type after replacing all of the Objective-C type
/// parameters with their corresponding arguments.
QualType substObjCMemberType(QualType objectType,
                             const DeclContext *dc,
                             ObjCSubstitutionContext context) const;

/// Strip Objective-C "__kindof" types from the given type.
QualType stripObjCKindOfType(const ASTContext &ctx) const;

/// Remove all qualifiers including _Atomic.
QualType getAtomicUnqualifiedType() const;

1240private:
// These methods are implemented in a separate translation unit;
// "static"-ize them to avoid creating temporary QualTypes in the
// caller.
static bool isConstant(QualType T, const ASTContext& Ctx);
static QualType getDesugaredType(QualType T, const ASTContext &Context);
static SplitQualType getSplitDesugaredType(QualType T);
static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
static QualType getSingleStepDesugaredTypeImpl(QualType type,
                                               const ASTContext &C);
static QualType IgnoreParens(QualType T);
static DestructionKind isDestructedTypeImpl(QualType type);

/// Check if \param RD is or contains a non-trivial C union.
static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1257};

1259} // namespace clang

1261namespace llvm {

1263/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1264/// to a specific Type class.
1265template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1271};

1273// Teach SmallPtrSet that QualType is "basically a pointer".
1274template<>
1275struct PointerLikeTypeTraits<clang::QualType> {
static inline void *getAsVoidPointer(clang::QualType P) {
  return P.getAsOpaquePtr();
}

static inline clang::QualType getFromVoidPointer(void *P) {
  return clang::QualType::getFromOpaquePtr(P);
}

// Various qualifiers go in low bits.
enum { NumLowBitsAvailable = 0 };
1286};

1288} // namespace llvm

1290namespace clang {

1292/// Base class that is common to both the \c ExtQuals and \c Type
1293/// classes, which allows \c QualType to access the common fields between the
1294/// two.
1295class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// The "base" type of an extended qualifiers type (\c ExtQuals) or
/// a self-referential pointer (for \c Type).
///
/// This pointer allows an efficient mapping from a QualType to its
/// underlying type pointer.
const Type *const BaseType;

/// The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1312};

1314/// We can encode up to four bits in the low bits of a
1315/// type pointer, but there are many more type qualifiers that we want
1316/// to be able to apply to an arbitrary type.  Therefore we have this
1317/// struct, intended to be heap-allocated and used by QualType to
1318/// store qualifiers.
1319///
1320/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1321/// in three low bits on the QualType pointer; a fourth bit records whether
1322/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1323/// Objective-C GC attributes) are much more rare.
1324class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
// NOTE: changing the fast qualifiers should be straightforward as
// long as you don't make 'const' non-fast.
// 1. Qualifiers:
//    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
//       Fast qualifiers must occupy the low-order bits.
//    b) Update Qualifiers::FastWidth and FastMask.
// 2. QualType:
//    a) Update is{Volatile,Restrict}Qualified(), defined inline.
//    b) Update remove{Volatile,Restrict}, defined near the end of
//       this header.
// 3. ASTContext:
//    a) Update get{Volatile,Restrict}Type.

/// The immutable set of qualifiers applied by this node. Always contains
/// extended qualifiers.
Qualifiers Quals;

ExtQuals *this_() { return this; }

1344public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1350, __PRETTY_FUNCTION__))
         && "ExtQuals created with no fast qualifiers")((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1350, __PRETTY_FUNCTION__));
  assert(!Quals.hasFastQualifiers()((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1352, __PRETTY_FUNCTION__))
         && "ExtQuals created with fast qualifiers")((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1352, __PRETTY_FUNCTION__));
}

Qualifiers getQualifiers() const { return Quals; }

bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }

bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return Quals.getObjCLifetime();
}

bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
LangAS getAddressSpace() const { return Quals.getAddressSpace(); }

const Type *getBaseType() const { return BaseType; }

1370public:
void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, getBaseType(), Quals);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const Type *BaseType,
                    Qualifiers Quals) {
  assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1378, __PRETTY_FUNCTION__));
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1382};

1384/// The kind of C++11 ref-qualifier associated with a function type.
1385/// This determines whether a member function's "this" object can be an
1386/// lvalue, rvalue, or neither.
1387enum RefQualifierKind {
/// No ref-qualifier was provided.
RQ_None = 0,

/// An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1396};

1398/// Which keyword(s) were used to create an AutoType.
1399enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1408};

1410/// The base class of the type hierarchy.
1411///
1412/// A central concept with types is that each type always has a canonical
1413/// type.  A canonical type is the type with any typedef names stripped out
1414/// of it or the types it references.  For example, consider:
1415///
1416///  typedef int  foo;
1417///  typedef foo* bar;
1418///    'int *'    'foo *'    'bar'
1419///
1420/// There will be a Type object created for 'int'.  Since int is canonical, its
1421/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1422/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1423/// there is a PointerType that represents 'int*', which, like 'int', is
1424/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1425/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1426/// is also 'int*'.
1427///
1428/// Non-canonical types are useful for emitting diagnostics, without losing
1429/// information about typedefs being used.  Canonical types are useful for type
1430/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1431/// about whether something has a particular form (e.g. is a function type),
1432/// because they implicitly, recursively, strip all typedefs out of a type.
1433///
1434/// Types, once created, are immutable.
1435///
1436class alignas(8) Type : public ExtQualsTypeCommonBase {
1437public:
enum TypeClass {
1439#define TYPE(Class, Base) Class,
1440#define LAST_TYPE(Class) TypeLast = Class
1441#define ABSTRACT_TYPE(Class, Base)
1442#include "clang/AST/TypeNodes.inc"
};

1445private:
/// Bitfields required by the Type class.
class TypeBitfields {
  friend class Type;
  template <class T> friend class TypePropertyCache;

  /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
  unsigned TC : 8;

  /// Whether this type is a dependent type (C++ [temp.dep.type]).
  unsigned Dependent : 1;

  /// Whether this type somehow involves a template parameter, even
  /// if the resolution of the type does not depend on a template parameter.
  unsigned InstantiationDependent : 1;

  /// Whether this type is a variably-modified type (C99 6.7.5).
  unsigned VariablyModified : 1;

  /// Whether this type contains an unexpanded parameter pack
  /// (for C++11 variadic templates).
  unsigned ContainsUnexpandedParameterPack : 1;

  /// True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// Whether this type comes from an AST file.
  mutable unsigned FromAST : 1;

  bool isCacheValid() const {
    return CacheValid;
  }

  Linkage getLinkage() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1486, __PRETTY_FUNCTION__));
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1491, __PRETTY_FUNCTION__));
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 18 };

1497protected:
// These classes allow subclasses to somewhat cleanly pack bitfields
// into Type.

class ArrayTypeBitfields {
  friend class ArrayType;

  unsigned : NumTypeBits;

  /// CVR qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  unsigned IndexTypeQuals : 3;

  /// Storage class qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  /// Actually an ArrayType::ArraySizeModifier.
  unsigned SizeModifier : 3;
};

class BuiltinTypeBitfields {
  friend class BuiltinType;

  unsigned : NumTypeBits;

  /// The kind (BuiltinType::Kind) of builtin type this is.
  unsigned Kind : 8;
};

/// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
/// Only common bits are stored here. Additional uncommon bits are stored
/// in a trailing object after FunctionProtoType.
class FunctionTypeBitfields {
  friend class FunctionProtoType;
  friend class FunctionType;

  unsigned : NumTypeBits;

  /// Extra information which affects how the function is called, like
  /// regparm and the calling convention.
  unsigned ExtInfo : 12;

  /// The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;

  /// Used only by FunctionProtoType, put here to pack with the
  /// other bitfields.
  /// The qualifiers are part of FunctionProtoType because...
  ///
  /// C++ 8.3.5p4: The return type, the parameter type list and the
  /// cv-qualifier-seq, [...], are part of the function type.
  unsigned FastTypeQuals : Qualifiers::FastWidth;
  /// Whether this function has extended Qualifiers.
  unsigned HasExtQuals : 1;

  /// The number of parameters this function has, not counting '...'.
  /// According to [implimits] 8 bits should be enough here but this is
  /// somewhat easy to exceed with metaprogramming and so we would like to
  /// keep NumParams as wide as reasonably possible.
  unsigned NumParams : 16;

  /// The type of exception specification this function has.
  unsigned ExceptionSpecType : 4;

  /// Whether this function has extended parameter information.
  unsigned HasExtParameterInfos : 1;

  /// Whether the function is variadic.
  unsigned Variadic : 1;

  /// Whether this function has a trailing return type.
  unsigned HasTrailingReturn : 1;
};

class ObjCObjectTypeBitfields {
  friend class ObjCObjectType;

  unsigned : NumTypeBits;

  /// The number of type arguments stored directly on this object type.
  unsigned NumTypeArgs : 7;

  /// The number of protocols stored directly on this object type.
  unsigned NumProtocols : 6;

  /// Whether this is a "kindof" type.
  unsigned IsKindOf : 1;
};

class ReferenceTypeBitfields {
  friend class ReferenceType;

  unsigned : NumTypeBits;

  /// True if the type was originally spelled with an lvalue sigil.
  /// This is never true of rvalue references but can also be false
  /// on lvalue references because of C++0x [dcl.typedef]p9,
  /// as follows:
  ///
  ///   typedef int &ref;    // lvalue, spelled lvalue
  ///   typedef int &&rvref; // rvalue
  ///   ref &a;              // lvalue, inner ref, spelled lvalue
  ///   ref &&a;             // lvalue, inner ref
  ///   rvref &a;            // lvalue, inner ref, spelled lvalue
  ///   rvref &&a;           // rvalue, inner ref
  unsigned SpelledAsLValue : 1;

  /// True if the inner type is a reference type.  This only happens
  /// in non-canonical forms.
  unsigned InnerRef : 1;
};

class TypeWithKeywordBitfields {
  friend class TypeWithKeyword;

  unsigned : NumTypeBits;

  /// An ElaboratedTypeKeyword.  8 bits for efficient access.
  unsigned Keyword : 8;
};

enum { NumTypeWithKeywordBits = 8 };

class ElaboratedTypeBitfields {
  friend class ElaboratedType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// Whether the ElaboratedType has a trailing OwnedTagDecl.
  unsigned HasOwnedTagDecl : 1;
};

class VectorTypeBitfields {
  friend class VectorType;
  friend class DependentVectorType;

  unsigned : NumTypeBits;

  /// The kind of vector, either a generic vector type or some
  /// target-specific vector type such as for AltiVec or Neon.
  unsigned VecKind : 3;

  /// The number of elements in the vector.
  unsigned NumElements : 29 - NumTypeBits;

  enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 };
};

class AttributedTypeBitfields {
  friend class AttributedType;

  unsigned : NumTypeBits;

  /// An AttributedType::Kind
  unsigned AttrKind : 32 - NumTypeBits;
};

class AutoTypeBitfields {
  friend class AutoType;

  unsigned : NumTypeBits;

  /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
  /// or '__auto_type'?  AutoTypeKeyword value.
  unsigned Keyword : 2;
};

class SubstTemplateTypeParmPackTypeBitfields {
  friend class SubstTemplateTypeParmPackType;

  unsigned : NumTypeBits;

  /// The number of template arguments in \c Arguments, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class TemplateSpecializationTypeBitfields {
  friend class TemplateSpecializationType;

  unsigned : NumTypeBits;

  /// Whether this template specialization type is a substituted type alias.
  unsigned TypeAlias : 1;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class DependentTemplateSpecializationTypeBitfields {
  friend class DependentTemplateSpecializationType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class PackExpansionTypeBitfields {
  friend class PackExpansionType;

  unsigned : NumTypeBits;

  /// The number of expansions that this pack expansion will
  /// generate when substituted (+1), which is expected to be able to
  /// hold at least 1024 according to [implimits]. However, as this limit
  /// is somewhat easy to hit with template metaprogramming we'd prefer to
  /// keep it as large as possible. At the moment it has been left as a
  /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
  /// there is no reason to introduce the performance impact of a bitfield.
  ///
  /// This field will only have a non-zero value when some of the parameter
  /// packs that occur within the pattern have been substituted but others
  /// have not.
  unsigned NumExpansions;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  ElaboratedTypeBitfields ElaboratedTypeBits;
  VectorTypeBitfields VectorTypeBits;
  SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
  TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
  DependentTemplateSpecializationTypeBitfields
    DependentTemplateSpecializationTypeBits;
  PackExpansionTypeBitfields PackExpansionTypeBits;

  static_assert(sizeof(TypeBitfields) <= 8,
                "TypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ArrayTypeBitfields) <= 8,
                "ArrayTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(AttributedTypeBitfields) <= 8,
                "AttributedTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(AutoTypeBitfields) <= 8,
                "AutoTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(BuiltinTypeBitfields) <= 8,
                "BuiltinTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(FunctionTypeBitfields) <= 8,
                "FunctionTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCObjectTypeBitfields) <= 8,
                "ObjCObjectTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ReferenceTypeBitfields) <= 8,
                "ReferenceTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(TypeWithKeywordBitfields) <= 8,
                "TypeWithKeywordBitfields is larger than 8 bytes!");
  static_assert(sizeof(ElaboratedTypeBitfields) <= 8,
                "ElaboratedTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(VectorTypeBitfields) <= 8,
                "VectorTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(SubstTemplateTypeParmPackTypeBitfields) <= 8,
                "SubstTemplateTypeParmPackTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8,
                "TemplateSpecializationTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(DependentTemplateSpecializationTypeBitfields) <= 8,
                "DependentTemplateSpecializationTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(PackExpansionTypeBitfields) <= 8,
                "PackExpansionTypeBitfields is larger than 8 bytes");
};

1787private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1795protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, bool Dependent,
     bool InstantiationDependent, bool VariablyModified,
     bool ContainsUnexpandedParameterPack)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  TypeBits.TC = tc;
  TypeBits.Dependent = Dependent;
  TypeBits.InstantiationDependent = Dependent || InstantiationDependent;
  TypeBits.VariablyModified = VariablyModified;
  TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
  TypeBits.CacheValid = false;
  TypeBits.CachedLocalOrUnnamed = false;
  TypeBits.CachedLinkage = NoLinkage;
  TypeBits.FromAST = false;
}

// silence VC++ warning C4355: 'this' : used in base member initializer list
Type *this_() { return this; }

void setDependent(bool D = true) {
  TypeBits.Dependent = D;
  if (D)
    TypeBits.InstantiationDependent = true;
}

void setInstantiationDependent(bool D = true) {
  TypeBits.InstantiationDependent = D; }

void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM; }

void setContainsUnexpandedParameterPack(bool PP = true) {
  TypeBits.ContainsUnexpandedParameterPack = PP;
}

1832public:
friend class ASTReader;
friend class ASTWriter;

Type(const Type &) = delete;
Type(Type &&) = delete;
Type &operator=(const Type &) = delete;
Type &operator=(Type &&) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// Whether this type is or contains an unexpanded parameter
/// pack, used to support C++0x variadic templates.
///
/// A type that contains a parameter pack shall be expanded by the
/// ellipsis operator at some point. For example, the typedef in the
/// following example contains an unexpanded parameter pack 'T':
///
/// \code
/// template<typename ...T>
/// struct X {
///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
/// };
/// \endcode
///
/// Note that this routine does not specify which
bool containsUnexpandedParameterPack() const {
  return TypeBits.ContainsUnexpandedParameterPack;
}

/// Determines if this type would be canonical if it had no further
/// qualification.
bool isCanonicalUnqualified() const {
  return CanonicalType == QualType(this, 0);
}

/// Pull a single level of sugar off of this locally-unqualified type.
/// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
/// or QualType::getSingleStepDesugaredType(const ASTContext&).
QualType getLocallyUnqualifiedSingleStepDesugaredType() const;

/// Types are partitioned into 3 broad categories (C99 6.2.5p1):
/// object types, function types, and incomplete types.

/// Return true if this is an incomplete type.
/// A type that can describe objects, but which lacks information needed to
/// determine its size (e.g. void, or a fwd declared struct). Clients of this
/// routine will need to determine if the size is actually required.
///
/// Def If non-null, and the type refers to some kind of declaration
/// that can be completed (such as a C struct, C++ class, or Objective-C
/// class), will be set to the declaration.
bool isIncompleteType(NamedDecl **Def = nullptr) const;

/// Return true if this is an incomplete or object
/// type, in other words, not a function type.
bool isIncompleteOrObjectType() const {
  return !isFunctionType();
}

/// Determine whether this type is an object type.
bool isObjectType() const {
  // C++ [basic.types]p8:
  //   An object type is a (possibly cv-qualified) type that is not a
  //   function type, not a reference type, and not a void type.
  return !isReferenceType() && !isFunctionType() && !isVoidType();
}

/// Return true if this is a literal type
/// (C++11 [basic.types]p10)
bool isLiteralType(const ASTContext &Ctx) const;

/// Test if this type is a standard-layout type.
/// (C++0x [basic.type]p9)
bool isStandardLayoutType() const;

/// Helper methods to distinguish type categories. All type predicates
/// operate on the canonical type, ignoring typedefs and qualifiers.

/// Returns true if the type is a builtin type.
bool isBuiltinType() const;

/// Test for a particular builtin type.
bool isSpecificBuiltinType(unsigned K) const;

/// Test for a type which does not represent an actual type-system type but
/// is instead used as a placeholder for various convenient purposes within
/// Clang.  All such types are BuiltinTypes.
bool isPlaceholderType() const;
const BuiltinType *getAsPlaceholderType() const;

/// Test for a specific placeholder type.
bool isSpecificPlaceholderType(unsigned K) const;

/// Test for a placeholder type other than Overload; see
/// BuiltinType::isNonOverloadPlaceholderType.
bool isNonOverloadPlaceholderType() const;

/// isIntegerType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
bool isEnumeralType() const;

/// Determine whether this type is a scoped enumeration type.
bool isScopedEnumeralType() const;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() const;
bool isChar8Type() const;
bool isChar16Type() const;
bool isChar32Type() const;
bool isAnyCharacterType() const;
bool isIntegralType(const ASTContext &Ctx) const;

/// Determine whether this type is an integral or enumeration type.
bool isIntegralOrEnumerationType() const;

/// Determine whether this type is an integral or unscoped enumeration type.
bool isIntegralOrUnscopedEnumerationType() const;

/// Floating point categories.
bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
/// isComplexType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isComplexType() const;      // C99 6.2.5p11 (complex)
bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
bool isFloat128Type() const;
bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
bool isVoidType() const;         // C99 6.2.5p19
bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
bool isAggregateType() const;
bool isFundamentalType() const;
bool isCompoundType() const;

// Type Predicates: Check to see if this type is structurally the specified
// type, ignoring typedefs and qualifiers.
bool isFunctionType() const;
bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
bool isPointerType() const;
bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
bool isBlockPointerType() const;
bool isVoidPointerType() const;
bool isReferenceType() const;
bool isLValueReferenceType() const;
bool isRValueReferenceType() const;
bool isFunctionPointerType() const;
bool isFunctionReferenceType() const;
bool isMemberPointerType() const;
bool isMemberFunctionPointerType() const;
bool isMemberDataPointerType() const;
bool isArrayType() const;
bool isConstantArrayType() const;
bool isIncompleteArrayType() const;
bool isVariableArrayType() const;
bool isDependentSizedArrayType() const;
bool isRecordType() const;
bool isClassType() const;
bool isStructureType() const;
bool isObjCBoxableRecordType() const;
bool isInterfaceType() const;
bool isStructureOrClassType() const;
bool isUnionType() const;
bool isComplexIntegerType() const;            // GCC _Complex integer type.
bool isVectorType() const;                    // GCC vector type.
bool isExtVectorType() const;                 // Extended vector type.
bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
bool isObjCObjectPointerType() const;         // pointer to ObjC object
bool isObjCRetainableType() const;            // ObjC object or block pointer
bool isObjCLifetimeType() const;              // (array of)* retainable type
bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
bool isObjCNSObjectType() const;              // __attribute__((NSObject))
bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
// FIXME: change this to 'raw' interface type, so we can used 'interface' type
// for the common case.
bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
bool isObjCQualifiedIdType() const;           // id<foo>
bool isObjCQualifiedClassType() const;        // Class<foo>
bool isObjCObjectOrInterfaceType() const;
bool isObjCIdType() const;                    // id
bool isDecltypeType() const;
/// Was this type written with the special inert-in-ARC __unsafe_unretained
/// qualifier?
///
/// This approximates the answer to the following question: if this
/// translation unit were compiled in ARC, would this type be qualified
/// with __unsafe_unretained?
bool isObjCInertUnsafeUnretainedType() const {
  return hasAttr(attr::ObjCInertUnsafeUnretained);
}

/// Whether the type is Objective-C 'id' or a __kindof type of an
/// object type, e.g., __kindof NSView * or __kindof id
/// <NSCopying>.
///
/// \param bound Will be set to the bound on non-id subtype types,
/// which will be (possibly specialized) Objective-C class type, or
/// null for 'id.
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
                                const ObjCObjectType *&bound) const;

bool isObjCClassType() const;                 // Class

/// Whether the type is Objective-C 'Class' or a __kindof type of an
/// Class type, e.g., __kindof Class <NSCopying>.
///
/// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
/// here because Objective-C's type system cannot express "a class
/// object for a subclass of NSFoo".
bool isObjCClassOrClassKindOfType() const;

bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
bool isObjCSelType() const;                 // Class
bool isObjCBuiltinType() const;               // 'id' or 'Class'
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const;          // C++ template type parameter
bool isNullPtrType() const;                   // C++11 std::nullptr_t
bool isNothrowT() const;                      // C++   std::nothrow_t
bool isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()

2063#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2065#include "clang/Basic/OpenCLImageTypes.def"

bool isImageType() const;                     // Any OpenCL image type

bool isSamplerT() const;                      // OpenCL sampler_t
bool isEventT() const;                        // OpenCL event_t
bool isClkEventT() const;                     // OpenCL clk_event_t
bool isQueueT() const;                        // OpenCL queue_t
bool isReserveIDT() const;                    // OpenCL reserve_id_t

2075#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2077#include "clang/Basic/OpenCLExtensionTypes.def"
// Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
bool isOCLIntelSubgroupAVCType() const;
bool isOCLExtOpaqueType() const;              // Any OpenCL extension type

bool isPipeType() const;                      // OpenCL pipe type
bool isOpenCLSpecificType() const;            // Any OpenCL specific type

/// Determines if this type, which must satisfy
/// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
/// than implicitly __strong.
bool isObjCARCImplicitlyUnretainedType() const;

/// Return the implicit lifetime for this type, which must not be dependent.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;

enum ScalarTypeKind {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
  STK_FixedPoint
};

/// Given that this is a scalar type, classify it.
ScalarTypeKind getScalarTypeKind() const;

/// Whether this type is a dependent type, meaning that its definition
/// somehow depends on a template parameter (C++ [temp.dep.type]).
bool isDependentType() const { return TypeBits.Dependent; }

/// Determine whether this type is an instantiation-dependent type,
/// meaning that the type involves a template parameter (even if the
/// definition does not actually depend on the type substituted for that
/// template parameter).
bool isInstantiationDependentType() const {
  return TypeBits.InstantiationDependent;
}

/// Determine whether this type is an undeduced type, meaning that
/// it somehow involves a C++11 'auto' type or similar which has not yet been
/// deduced.
bool isUndeducedType() const;

/// Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const { return TypeBits.VariablyModified; }

/// Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// Determine wither this type is a C++ elaborated-type-specifier.
bool isElaboratedTypeSpecifier() const;

bool canDecayToPointerType() const;

/// Whether this type is represented natively as a pointer.  This includes
/// pointers, references, block pointers, and Objective-C interface,
/// qualified id, and qualified interface types, as well as nullptr_t.
bool hasPointerRepresentation() const;

/// Whether this type can represent an objective pointer type for the
/// purpose of GC'ability
bool hasObjCPointerRepresentation() const;

/// Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// Determine whether this type has an signed integer representation
/// of some sort, e.g., it is an signed integer type or a vector.
bool hasSignedIntegerRepresentation() const;

/// Determine whether this type has an unsigned integer representation
/// of some sort, e.g., it is an unsigned integer type or a vector.
bool hasUnsignedIntegerRepresentation() const;

/// Determine whether this type has a floating-point representation
/// of some sort, e.g., it is a floating-point type or a vector thereof.
bool hasFloatingRepresentation() const;

// Type Checking Functions: Check to see if this type is structurally the
// specified type, ignoring typedefs and qualifiers, and return a pointer to
// the best type we can.
const RecordType *getAsStructureType() const;
/// NOTE: getAs*ArrayType are methods on ASTContext.
const RecordType *getAsUnionType() const;
const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
const ObjCObjectType *getAsObjCInterfaceType() const;

// The following is a convenience method that returns an ObjCObjectPointerType
// for object declared using an interface.
const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;

/// Retrieves the CXXRecordDecl that this type refers to, either
/// because the type is a RecordType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
CXXRecordDecl *getAsCXXRecordDecl() const;

/// Retrieves the RecordDecl this type refers to.
RecordDecl *getAsRecordDecl() const;

/// Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const;

/// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that the type refers to.
///
/// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const;

/// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
DeducedType *getContainedDeducedType() const;

/// Get the AutoType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
AutoType *getContainedAutoType() const {
  return dyn_cast_or_null<AutoType>(getContainedDeducedType());
}

/// Determine whether this type was written with a leading 'auto'
/// corresponding to a trailing return type (possibly for a nested
/// function type within a pointer to function type or similar).
bool hasAutoForTrailingReturnType() const;

/// Member-template getAs<specific type>'.  Look through sugar for
/// an instance of \<specific type>.   This scheme will eventually
/// replace the specific getAsXXXX methods above.
///
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;

/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
/// This is used when you need to walk over sugar nodes that represent some
/// kind of type adjustment from a type that was written as a \<specific type>
/// to another type that is still canonically a \<specific type>.
template <typename T> const T *getAsAdjusted() const;

/// A variant of getAs<> for array types which silently discards
/// qualifiers from the outermost type.
const ArrayType *getAsArrayTypeUnsafe() const;

/// Member-template castAs<specific type>.  Look through sugar for
/// the underlying instance of \<specific type>.
///
/// This method has the same relationship to getAs<T> as cast<T> has
/// to dyn_cast<T>; which is to say, the underlying type *must*
/// have the intended type, and this method will never return null.
template <typename T> const T *castAs() const;

/// A variant of castAs<> for array type which silently discards
/// qualifiers from the outermost type.
const ArrayType *castAsArrayTypeUnsafe() const;

/// Determine whether this type had the specified attribute applied to it
/// (looking through top-level type sugar).
bool hasAttr(attr::Kind AK) const;

/// Get the base element type of this type, potentially discarding type
/// qualifiers.  This should never be used when type qualifiers
/// are meaningful.
const Type *getBaseElementTypeUnsafe() const;

/// If this is an array type, return the element type of the array,
/// potentially with type qualifiers missing.
/// This should never be used when type qualifiers are meaningful.
const Type *getArrayElementTypeNoTypeQual() const;

/// If this is a pointer type, return the pointee type.
/// If this is an array type, return the array element type.
/// This should never be used when type qualifiers are meaningful.
const Type *getPointeeOrArrayElementType() const;

/// If this is a pointer, ObjC object pointer, or block
/// pointer, this returns the respective pointee.
QualType getPointeeType() const;

/// Return the specified type with any "sugar" removed from the type,
/// removing any typedefs, typeofs, etc., as well as any qualifiers.
const Type *getUnqualifiedDesugaredType() const;

/// More type predicates useful for type checking/promotion
bool isPromotableIntegerType() const; // C99 6.3.1.1p2

/// Return true if this is an integer type that is
/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
/// or an enum decl which has a signed representation.
bool isSignedIntegerType() const;

/// Return true if this is an integer type that is
/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
/// or an enum decl which has an unsigned representation.
bool isUnsignedIntegerType() const;

/// Determines whether this is an integer type that is signed or an
/// enumeration types whose underlying type is a signed integer type.
bool isSignedIntegerOrEnumerationType() const;

/// Determines whether this is an integer type that is unsigned or an
/// enumeration types whose underlying type is a unsigned integer type.
bool isUnsignedIntegerOrEnumerationType() const;

/// Return true if this is a fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169.
bool isFixedPointType() const;

/// Return true if this is a fixed point or integer type.
bool isFixedPointOrIntegerType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isSaturatedFixedPointType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isUnsaturatedFixedPointType() const;

/// Return true if this is a fixed point type that is signed according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isSignedFixedPointType() const;

/// Return true if this is a fixed point type that is unsigned according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isUnsignedFixedPointType() const;

/// Return true if this is not a variable sized type,
/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
/// incomplete types.
bool isConstantSizeType() const;

/// Returns true if this type can be represented by some
/// set of type specifiers.
bool isSpecifierType() const;

/// Determine the linkage of this type.
Linkage getLinkage() const;

/// Determine the visibility of this type.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Return true if the visibility was explicitly set is the code.
bool isVisibilityExplicit() const {
  return getLinkageAndVisibility().isVisibilityExplicit();
}

/// Determine the linkage and visibility of this type.
LinkageInfo getLinkageAndVisibility() const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// Determine the nullability of the given type.
///
/// Note that nullability is only captured as sugar within the type
/// system, not as part of the canonical type, so nullability will
/// be lost by canonicalization and desugaring.
Optional<NullabilityKind> getNullability(const ASTContext &context) const;

/// Determine whether the given type can have a nullability
/// specifier applied to it, i.e., if it is any kind of pointer type.
///
/// \param ResultIfUnknown The value to return if we don't yet know whether
///        this type can have nullability because it is dependent.
bool canHaveNullability(bool ResultIfUnknown = true) const;

/// Retrieve the set of substitutions required when accessing a member
/// of the Objective-C receiver type that is declared in the given context.
///
/// \c *this is the type of the object we're operating on, e.g., the
/// receiver for a message send or the base of a property access, and is
/// expected to be of some object or object pointer type.
///
/// \param dc The declaration context for which we are building up a
/// substitution mapping, which should be an Objective-C class, extension,
/// category, or method within.
///
/// \returns an array of type arguments that can be substituted for
/// the type parameters of the given declaration context in any type described
/// within that context, or an empty optional to indicate that no
/// substitution is required.
Optional<ArrayRef<QualType>>
getObjCSubstitutions(const DeclContext *dc) const;

/// Determines if this is an ObjC interface type that may accept type
/// parameters.
bool acceptsObjCTypeParams() const;

const char *getTypeClassName() const;

QualType getCanonicalTypeInternal() const {
  return CanonicalType;
}

CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
void dump() const;
void dump(llvm::raw_ostream &OS) const;
2397};

2399/// This will check for a TypedefType by removing any existing sugar
2400/// until it reaches a TypedefType or a non-sugared type.
2401template <> const TypedefType *Type::getAs() const;

2403/// This will check for a TemplateSpecializationType by removing any
2404/// existing sugar until it reaches a TemplateSpecializationType or a
2405/// non-sugared type.
2406template <> const TemplateSpecializationType *Type::getAs() const;

2408/// This will check for an AttributedType by removing any existing sugar
2409/// until it reaches an AttributedType or a non-sugared type.
2410template <> const AttributedType *Type::getAs() const;

2412// We can do canonical leaf types faster, because we don't have to
2413// worry about preserving child type decoration.
2414#define TYPE(Class, Base)
2415#define LEAF_TYPE(Class) \
2416template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2418} \
2419template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2421}
2422#include "clang/AST/TypeNodes.inc"

2424/// This class is used for builtin types like 'int'.  Builtin
2425/// types are always canonical and have a literal name field.
2426class BuiltinType : public Type {
2427public:
enum Kind {
2429// OpenCL image types
2430#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2431#include "clang/Basic/OpenCLImageTypes.def"
2432// OpenCL extension types
2433#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2434#include "clang/Basic/OpenCLExtensionTypes.def"
2435// SVE Types
2436#define SVE_TYPE(Name, Id, SingletonId) Id,
2437#include "clang/Basic/AArch64SVEACLETypes.def"
2438// All other builtin types
2439#define BUILTIN_TYPE(Id, SingletonId) Id,
2440#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2441#include "clang/AST/BuiltinTypes.def"
};

2444private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent),
           /*InstantiationDependent=*/(K == Dependent),
           /*VariablyModified=*/false,
           /*Unexpanded parameter pack=*/false) {
  BuiltinTypeBits.Kind = K;
}

2455public:
Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
StringRef getName(const PrintingPolicy &Policy) const;

const char *getNameAsCString(const PrintingPolicy &Policy) const {
  // The StringRef is null-terminated.
  StringRef str = getName(Policy);
  assert(!str.empty() && str.data()[str.size()] == '\0')((!str.empty() && str.data()[str.size()] == '\0') ? static_cast
<void> (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 2462, __PRETTY_FUNCTION__));
  return str.data();
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

bool isInteger() const {
  return getKind() >= Bool && getKind() <= Int128;
}

bool isSignedInteger() const {
  return getKind() >= Char_S && getKind() <= Int128;
}

bool isUnsignedInteger() const {
  return getKind() >= Bool && getKind() <= UInt128;
}

bool isFloatingPoint() const {
  return getKind() >= Half && getKind() <= Float128;
}

/// Determines whether the given kind corresponds to a placeholder type.
static bool isPlaceholderTypeKind(Kind K) {
  return K >= Overload;
}

/// Determines whether this type is a placeholder type, i.e. a type
/// which cannot appear in arbitrary positions in a fully-formed
/// expression.
bool isPlaceholderType() const {
  return isPlaceholderTypeKind(getKind());
}

/// Determines whether this type is a placeholder type other than
/// Overload.  Most placeholder types require only syntactic
/// information about their context in order to be resolved (e.g.
/// whether it is a call expression), which means they can (and
/// should) be resolved in an earlier "phase" of analysis.
/// Overload expressions sometimes pick up further information
/// from their context, like whether the context expects a
/// specific function-pointer type, and so frequently need
/// special treatment.
bool isNonOverloadPlaceholderType() const {
  return getKind() > Overload;
}

static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2511};

2513/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2514/// types (_Complex float etc) as well as the GCC integer complex extensions.
2515class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->isDependentType(),
           Element->isInstantiationDependentType(),
           Element->isVariablyModifiedType(),
           Element->containsUnexpandedParameterPack()),
      ElementType(Element) {}

2527public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
  ID.AddPointer(Element.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2542};

2544/// Sugar for parentheses used when specifying types.
2545class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->isDependentType(),
           InnerType->isInstantiationDependentType(),
           InnerType->isVariablyModifiedType(),
           InnerType->containsUnexpandedParameterPack()),
      Inner(InnerType) {}

2557public:
QualType getInnerType() const { return Inner; }

bool isSugared() const { return true; }
QualType desugar() const { return getInnerType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getInnerType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
  Inner.Profile(ID);
}

static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2572};

2574/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2575class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

2587public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if address spaces of pointers overlap.
/// OpenCL v2.0 defines conversion rules for pointers to different
/// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping
/// address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// CL2.0 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(const PointerType &other) const {
  Qualifiers thisQuals = PointeeType.getQualifiers();
  Qualifiers otherQuals = other.getPointeeType().getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return thisQuals.isAddressSpaceSupersetOf(otherQuals) ||
         otherQuals.isAddressSpaceSupersetOf(thisQuals);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2618};

2620/// Represents a type which was implicitly adjusted by the semantic
2621/// engine for arbitrary reasons.  For example, array and function types can
2622/// decay, and function types can have their calling conventions adjusted.
2623class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2627protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->isDependentType(),
           OriginalTy->isInstantiationDependentType(),
           OriginalTy->isVariablyModifiedType(),
           OriginalTy->containsUnexpandedParameterPack()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2638public:
QualType getOriginalType() const { return OriginalTy; }
QualType getAdjustedType() const { return AdjustedTy; }

bool isSugared() const { return true; }
QualType desugar() const { return AdjustedTy; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, OriginalTy, AdjustedTy);
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
  ID.AddPointer(Orig.getAsOpaquePtr());
  ID.AddPointer(New.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
}
2657};

2659/// Represents a pointer type decayed from an array or function type.
2660class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2666public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2672};

2674/// Pointer to a block type.
2675/// This type is to represent types syntactically represented as
2676/// "void (^)(int)", etc. Pointee is required to always be a function type.
2677class BlockPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

// Block is some kind of pointer type
QualType PointeeType;

BlockPointerType(QualType Pointee, QualType CanonicalCls)
    : Type(BlockPointer, CanonicalCls, Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

2690public:
// Get the pointee type. Pointee is required to always be a function type.
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
    Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
    ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == BlockPointer;
}
2708};

2710/// Base for LValueReferenceType and RValueReferenceType
2711class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2714protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->isDependentType(),
           Referencee->isInstantiationDependentType(),
           Referencee->isVariablyModifiedType(),
           Referencee->containsUnexpandedParameterPack()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2726public:
bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }

QualType getPointeeTypeAsWritten() const { return PointeeType; }

QualType getPointeeType() const {
  // FIXME: this might strip inner qualifiers; okay?
  const ReferenceType *T = this;
  while (T->isInnerRef())
    T = T->PointeeType->castAs<ReferenceType>();
  return T->PointeeType;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, PointeeType, isSpelledAsLValue());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Referencee,
                    bool SpelledAsLValue) {
  ID.AddPointer(Referencee.getAsOpaquePtr());
  ID.AddBoolean(SpelledAsLValue);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference ||
         T->getTypeClass() == RValueReference;
}
2755};

2757/// An lvalue reference type, per C++11 [dcl.ref].
2758class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2766public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2773};

2775/// An rvalue reference type, per C++11 [dcl.ref].
2776class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2782public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2789};

2791/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2792///
2793/// This includes both pointers to data members and pointer to member functions.
2794class MemberPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

/// The class of which the pointee is a member. Must ultimately be a
/// RecordType, but could be a typedef or a template parameter too.
const Type *Class;

MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
    : Type(MemberPointer, CanonicalPtr,
           Cls->isDependentType() || Pointee->isDependentType(),
           (Cls->isInstantiationDependentType() ||
            Pointee->isInstantiationDependentType()),
           Pointee->isVariablyModifiedType(),
           (Cls->containsUnexpandedParameterPack() ||
            Pointee->containsUnexpandedParameterPack())),
           PointeeType(Pointee), Class(Cls) {}

2813public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if the member type (i.e. the pointee type) is a
/// function type rather than a data-member type.
bool isMemberFunctionPointer() const {
  return PointeeType->isFunctionProtoType();
}

/// Returns true if the member type (i.e. the pointee type) is a
/// data type rather than a function type.
bool isMemberDataPointer() const {
  return !PointeeType->isFunctionProtoType();
}

const Type *getClass() const { return Class; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType(), getClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
                    const Type *Class) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
  ID.AddPointer(Class);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == MemberPointer;
}
2847};

2849/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2850class ArrayType : public Type, public llvm::FoldingSetNode {
2851public:
/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum ArraySizeModifier {
  Normal, Static, Star
};

2860private:
/// The element type of the array.
QualType ElementType;

2864protected:
friend class ASTContext; // ASTContext creates these.

// C++ [temp.dep.type]p1:
//   A type is dependent if it is...
//     - an array type constructed from any dependent type or whose
//       size is specified by a constant expression that is
//       value-dependent,
ArrayType(TypeClass tc, QualType et, QualType can,
          ArraySizeModifier sm, unsigned tq,
          bool ContainsUnexpandedParameterPack)
    : Type(tc, can, et->isDependentType() || tc == DependentSizedArray,
           et->isInstantiationDependentType() || tc == DependentSizedArray,
           (tc == VariableArray || et->isVariablyModifiedType()),
           ContainsUnexpandedParameterPack),
      ElementType(et) {
  ArrayTypeBits.IndexTypeQuals = tq;
  ArrayTypeBits.SizeModifier = sm;
}

2884public:
QualType getElementType() const { return ElementType; }

ArraySizeModifier getSizeModifier() const {
  return ArraySizeModifier(ArrayTypeBits.SizeModifier);
}

Qualifiers getIndexTypeQualifiers() const {
  return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
}

unsigned getIndexTypeCVRQualifiers() const {
  return ArrayTypeBits.IndexTypeQuals;
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray ||
         T->getTypeClass() == VariableArray ||
         T->getTypeClass() == IncompleteArray ||
         T->getTypeClass() == DependentSizedArray;
}
2905};

2907/// Represents the canonical version of C arrays with a specified constant size.
2908/// For example, the canonical type for 'int A[4 + 4*100]' is a
2909/// ConstantArrayType where the element type is 'int' and the size is 404.
2910class ConstantArrayType : public ArrayType {
llvm::APInt Size; // Allows us to unique the type.

ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
                  ArraySizeModifier sm, unsigned tq)
    : ArrayType(ConstantArray, et, can, sm, tq,
                et->containsUnexpandedParameterPack()),
      Size(size) {}

2919protected:
friend class ASTContext; // ASTContext creates these.

ConstantArrayType(TypeClass tc, QualType et, QualType can,
                  const llvm::APInt &size, ArraySizeModifier sm, unsigned tq)
    : ArrayType(tc, et, can, sm, tq, et->containsUnexpandedParameterPack()),
      Size(size) {}

2927public:
const llvm::APInt &getSize() const { return Size; }
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Determine the number of bits required to address a member of
// an array with the given element type and number of elements.
static unsigned getNumAddressingBits(const ASTContext &Context,
                                     QualType ElementType,
                                     const llvm::APInt &NumElements);

/// Determine the maximum number of active bits that an array's size
/// can require, which limits the maximum size of the array.
static unsigned getMaxSizeBits(const ASTContext &Context);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSize(),
          getSizeModifier(), getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    const llvm::APInt &ArraySize, ArraySizeModifier SizeMod,
                    unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(ArraySize.getZExtValue());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray;
}
2959};

2961/// Represents a C array with an unspecified size.  For example 'int A[]' has
2962/// an IncompleteArrayType where the element type is 'int' and the size is
2963/// unspecified.
2964class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq,
                et->containsUnexpandedParameterPack()) {}

2972public:
friend class StmtIteratorBase;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == IncompleteArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSizeModifier(),
          getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    ArraySizeModifier SizeMod, unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}
2993};

2995/// Represents a C array with a specified size that is not an
2996/// integer-constant-expression.  For example, 'int s[x+foo()]'.
2997/// Since the size expression is an arbitrary expression, we store it as such.
2998///
2999/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3000/// should not be: two lexically equivalent variable array types could mean
3001/// different things, for example, these variables do not have the same type
3002/// dynamically:
3003///
3004/// void foo(int x) {
3005///   int Y[x];
3006///   ++x;
3007///   int Z[x];
3008/// }
3009class VariableArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

/// An assignment-expression. VLA's are only permitted within
/// a function block.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

VariableArrayType(QualType et, QualType can, Expr *e,
                  ArraySizeModifier sm, unsigned tq,
                  SourceRange brackets)
    : ArrayType(VariableArray, et, can, sm, tq,
                et->containsUnexpandedParameterPack()),
      SizeExpr((Stmt*) e), Brackets(brackets) {}

3026public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == VariableArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  llvm_unreachable("Cannot unique VariableArrayTypes.")::llvm::llvm_unreachable_internal("Cannot unique VariableArrayTypes."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3047);
}
3049};

3051/// Represents an array type in C++ whose size is a value-dependent expression.
3052///
3053/// For example:
3054/// \code
3055/// template<typename T, int Size>
3056/// class array {
3057///   T data[Size];
3058/// };
3059/// \endcode
3060///
3061/// For these types, we won't actually know what the array bound is
3062/// until template instantiation occurs, at which point this will
3063/// become either a ConstantArrayType or a VariableArrayType.
3064class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// An assignment expression that will instantiate to the
/// size of the array.
///
/// The expression itself might be null, in which case the array
/// type will have its size deduced from an initializer.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
                        Expr *e, ArraySizeModifier sm, unsigned tq,
                        SourceRange brackets);

3083public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(),
          getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ET, ArraySizeModifier SizeMod,
                    unsigned TypeQuals, Expr *E);
3111};

3113/// Represents an extended address space qualifier where the input address space
3114/// value is dependent. Non-dependent address spaces are not represented with a
3115/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3116///
3117/// For example:
3118/// \code
3119/// template<typename T, int AddrSpace>
3120/// class AddressSpace {
3121///   typedef T __attribute__((address_space(AddrSpace))) type;
3122/// }
3123/// \endcode
3124class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *AddrSpaceExpr;
QualType PointeeType;
SourceLocation loc;

DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
                          QualType can, Expr *AddrSpaceExpr,
                          SourceLocation loc);

3136public:
Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
QualType getPointeeType() const { return PointeeType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentAddressSpace;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType PointeeType, Expr *AddrSpaceExpr);
3154};

3156/// Represents an extended vector type where either the type or size is
3157/// dependent.
3158///
3159/// For example:
3160/// \code
3161/// template<typename T, int Size>
3162/// class vector {
3163///   typedef T __attribute__((ext_vector_type(Size))) type;
3164/// }
3165/// \endcode
3166class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *SizeExpr;

/// The element type of the array.
QualType ElementType;

SourceLocation loc;

DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
                            QualType can, Expr *SizeExpr, SourceLocation loc);

3180public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedExtVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *SizeExpr);
3198};


3201/// Represents a GCC generic vector type. This type is created using
3202/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3203/// bytes; or from an Altivec __vector or vector declaration.
3204/// Since the constructor takes the number of vector elements, the
3205/// client is responsible for converting the size into the number of elements.
3206class VectorType : public Type, public llvm::FoldingSetNode {
3207public:
enum VectorKind {
  /// not a target-specific vector type
  GenericVector,

  /// is AltiVec vector
  AltiVecVector,

  /// is AltiVec 'vector Pixel'
  AltiVecPixel,

  /// is AltiVec 'vector bool ...'
  AltiVecBool,

  /// is ARM Neon vector
  NeonVector,

  /// is ARM Neon polynomial vector
  NeonPolyVector
};

3228protected:
friend class ASTContext; // ASTContext creates these.

/// The element type of the vector.
QualType ElementType;

VectorType(QualType vecType, unsigned nElements, QualType canonType,
           VectorKind vecKind);

VectorType(TypeClass tc, QualType vecType, unsigned nElements,
           QualType canonType, VectorKind vecKind);

3240public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

static bool isVectorSizeTooLarge(unsigned NumElements) {
  return NumElements > VectorTypeBitfields::MaxNumElements;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

VectorKind getVectorKind() const {
  return VectorKind(VectorTypeBits.VecKind);
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumElements(),
          getTypeClass(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumElements, TypeClass TypeClass,
                    VectorKind VecKind) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumElements);
  ID.AddInteger(TypeClass);
  ID.AddInteger(VecKind);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
}
3272};

3274/// Represents a vector type where either the type or size is dependent.
3275////
3276/// For example:
3277/// \code
3278/// template<typename T, int Size>
3279/// class vector {
3280///   typedef T __attribute__((vector_size(Size))) type;
3281/// }
3282/// \endcode
3283class DependentVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
QualType ElementType;
Expr *SizeExpr;
SourceLocation Loc;

DependentVectorType(const ASTContext &Context, QualType ElementType,
                         QualType CanonType, Expr *SizeExpr,
                         SourceLocation Loc, VectorType::VectorKind vecKind);

3295public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return Loc; }
VectorType::VectorKind getVectorKind() const {
  return VectorType::VectorKind(VectorTypeBits.VecKind);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, const Expr *SizeExpr,
                    VectorType::VectorKind VecKind);
3317};

3319/// ExtVectorType - Extended vector type. This type is created using
3320/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3321/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3322/// class enables syntactic extensions, like Vector Components for accessing
3323/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3324/// Shading Language).
3325class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3331public:
static int getPointAccessorIdx(char c) {
  switch (c) {
  default: return -1;
  case 'x': case 'r': return 0;
  case 'y': case 'g': return 1;
  case 'z': case 'b': return 2;
  case 'w': case 'a': return 3;
  }
}

static int getNumericAccessorIdx(char c) {
  switch (c) {
    default: return -1;
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'A':
    case 'a': return 10;
    case 'B':
    case 'b': return 11;
    case 'C':
    case 'c': return 12;
    case 'D':
    case 'd': return 13;
    case 'E':
    case 'e': return 14;
    case 'F':
    case 'f': return 15;
  }
}

static int getAccessorIdx(char c, bool isNumericAccessor) {
  if (isNumericAccessor)
    return getNumericAccessorIdx(c);
  else
    return getPointAccessorIdx(c);
}

bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
  if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
    return unsigned(idx-1) < getNumElements();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ExtVector;
}
3389};

3391/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3392/// class of FunctionNoProtoType and FunctionProtoType.
3393class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3397public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type. This is only used by FunctionProtoType
/// but is in FunctionType to make this class available during the
/// specification of the bases of FunctionProtoType.
///
/// It makes sense to model language features this way when there's some
/// sort of parameter-specific override (such as an attribute) that
/// affects how the function is called.  For example, the ARC ns_consumed
/// attribute changes whether a parameter is passed at +0 (the default)
/// or +1 (ns_consumed).  This must be reflected in the function type,
/// but isn't really a change to the parameter type.
///
/// One serious disadvantage of modelling language features this way is
/// that they generally do not work with language features that attempt
/// to destructure types.  For example, template argument deduction will
/// not be able to match a parameter declared as
///   T (*)(U)
/// against an argument of type
///   void (*)(__attribute__((ns_consumed)) id)
/// because the substitution of T=void, U=id into the former will
/// not produce the latter.
class ExtParameterInfo {
  enum {
    ABIMask = 0x0F,
    IsConsumed = 0x10,
    HasPassObjSize = 0x20,
    IsNoEscape = 0x40,
  };
  unsigned char Data = 0;

public:
  ExtParameterInfo() = default;

  /// Return the ABI treatment of this parameter.
  ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
  ExtParameterInfo withABI(ParameterABI kind) const {
    ExtParameterInfo copy = *this;
    copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
    return copy;
  }

  /// Is this parameter considered "consumed" by Objective-C ARC?
  /// Consumed parameters must have retainable object type.
  bool isConsumed() const { return (Data & IsConsumed); }
  ExtParameterInfo withIsConsumed(bool consumed) const {
    ExtParameterInfo copy = *this;
    if (consumed)
      copy.Data |= IsConsumed;
    else
      copy.Data &= ~IsConsumed;
    return copy;
  }

  bool hasPassObjectSize() const { return Data & HasPassObjSize; }
  ExtParameterInfo withHasPassObjectSize() const {
    ExtParameterInfo Copy = *this;
    Copy.Data |= HasPassObjSize;
    return Copy;
  }

  bool isNoEscape() const { return Data & IsNoEscape; }
  ExtParameterInfo withIsNoEscape(bool NoEscape) const {
    ExtParameterInfo Copy = *this;
    if (NoEscape)
      Copy.Data |= IsNoEscape;
    else
      Copy.Data &= ~IsNoEscape;
    return Copy;
  }

  unsigned char getOpaqueValue() const { return Data; }
  static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
    ExtParameterInfo result;
    result.Data = data;
    return result;
  }

  friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data == rhs.Data;
  }

  friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data != rhs.Data;
  }
};

/// A class which abstracts out some details necessary for
/// making a call.
///
/// It is not actually used directly for storing this information in
/// a FunctionType, although FunctionType does currently use the
/// same bit-pattern.
///
// If you add a field (say Foo), other than the obvious places (both,
// constructors, compile failures), what you need to update is
// * Operator==
// * getFoo
// * withFoo
// * functionType. Add Foo, getFoo.
// * ASTContext::getFooType
// * ASTContext::mergeFunctionTypes
// * FunctionNoProtoType::Profile
// * FunctionProtoType::Profile
// * TypePrinter::PrintFunctionProto
// * AST read and write
// * Codegen
class ExtInfo {
  friend class FunctionType;

  // Feel free to rearrange or add bits, but if you go over 12,
  // you'll need to adjust both the Bits field below and
  // Type::FunctionTypeBitfields.

  //   |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|
  //   |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |
  //
  // regparm is either 0 (no regparm attribute) or the regparm value+1.
  enum { CallConvMask = 0x1F };
  enum { NoReturnMask = 0x20 };
  enum { ProducesResultMask = 0x40 };
  enum { NoCallerSavedRegsMask = 0x80 };
  enum { NoCfCheckMask = 0x800 };
  enum {
    RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask |
                    NoCallerSavedRegsMask | NoCfCheckMask),
    RegParmOffset = 8
  }; // Assumed to be the last field
  uint16_t Bits = CC_C;

  ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

 public:
   // Constructor with no defaults. Use this when you know that you
   // have all the elements (when reading an AST file for example).
   ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
           bool producesResult, bool noCallerSavedRegs, bool NoCfCheck) {
     assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(((!hasRegParm || regParm < 7) && "Invalid regparm value"
) ? static_cast<void> (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3534, __PRETTY_FUNCTION__));
     Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
            (producesResult ? ProducesResultMask : 0) |
            (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
            (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
            (NoCfCheck ? NoCfCheckMask : 0);
  }

  // Constructor with all defaults. Use when for example creating a
  // function known to use defaults.
  ExtInfo() = default;

  // Constructor with just the calling convention, which is an important part
  // of the canonical type.
  ExtInfo(CallingConv CC) : Bits(CC) {}

  bool getNoReturn() const { return Bits & NoReturnMask; }
  bool getProducesResult() const { return Bits & ProducesResultMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
    if (RegParm > 0)
      --RegParm;
    return RegParm;
  }

  CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }

  bool operator==(ExtInfo Other) const {
    return Bits == Other.Bits;
  }
  bool operator!=(ExtInfo Other) const {
    return Bits != Other.Bits;
  }

  // Note that we don't have setters. That is by design, use
  // the following with methods instead of mutating these objects.

  ExtInfo withNoReturn(bool noReturn) const {
    if (noReturn)
      return ExtInfo(Bits | NoReturnMask);
    else
      return ExtInfo(Bits & ~NoReturnMask);
  }

  ExtInfo withProducesResult(bool producesResult) const {
    if (producesResult)
      return ExtInfo(Bits | ProducesResultMask);
    else
      return ExtInfo(Bits & ~ProducesResultMask);
  }

  ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
    if (noCallerSavedRegs)
      return ExtInfo(Bits | NoCallerSavedRegsMask);
    else
      return ExtInfo(Bits & ~NoCallerSavedRegsMask);
  }

  ExtInfo withNoCfCheck(bool noCfCheck) const {
    if (noCfCheck)
      return ExtInfo(Bits | NoCfCheckMask);
    else
      return ExtInfo(Bits & ~NoCfCheckMask);
  }

  ExtInfo withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")((RegParm < 7 && "Invalid regparm value") ? static_cast
<void> (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3604, __PRETTY_FUNCTION__));
    return ExtInfo((Bits & ~RegParmMask) |
                   ((RegParm + 1) << RegParmOffset));
  }

  ExtInfo withCallingConv(CallingConv cc) const {
    return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
  }

  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.AddInteger(Bits);
  }
};

/// A simple holder for a QualType representing a type in an
/// exception specification. Unfortunately needed by FunctionProtoType
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };

/// A simple holder for various uncommon bits which do not fit in
/// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
/// alignment of subsequent objects in TrailingObjects. You must update
/// hasExtraBitfields in FunctionProtoType after adding extra data here.
struct alignas(void *) FunctionTypeExtraBitfields {
  /// The number of types in the exception specification.
  /// A whole unsigned is not needed here and according to
  /// [implimits] 8 bits would be enough here.
  unsigned NumExceptionType;
};

3634protected:
FunctionType(TypeClass tc, QualType res,
             QualType Canonical, bool Dependent,
             bool InstantiationDependent,
             bool VariablyModified, bool ContainsUnexpandedParameterPack,
             ExtInfo Info)
    : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
           ContainsUnexpandedParameterPack),
      ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3650public:
QualType getReturnType() const { return ResultType; }

bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
unsigned getRegParmType() const { return getExtInfo().getRegParm(); }

/// Determine whether this function type includes the GNU noreturn
/// attribute. The C++11 [[noreturn]] attribute does not affect the function
/// type.
bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }

CallingConv getCallConv() const { return getExtInfo().getCC(); }
ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }

static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
              "Const, volatile and restrict are assumed to be a subset of "
              "the fast qualifiers.");

bool isConst() const { return getFastTypeQuals().hasConst(); }
bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }

/// Determine the type of an expression that calls a function of
/// this type.
QualType getCallResultType(const ASTContext &Context) const {
  return getReturnType().getNonLValueExprType(Context);
}

static StringRef getNameForCallConv(CallingConv CC);

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto ||
         T->getTypeClass() == FunctionProto;
}
3684};

3686/// Represents a K&R-style 'int foo()' function, which has
3687/// no information available about its arguments.
3688class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   /*Dependent=*/false, /*InstantiationDependent=*/false,
                   Result->isVariablyModifiedType(),
                   /*ContainsUnexpandedParameterPack=*/false, Info) {}

3697public:
// No additional state past what FunctionType provides.

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReturnType(), getExtInfo());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
                    ExtInfo Info) {
  Info.Profile(ID);
  ID.AddPointer(ResultType.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto;
}
3716};

3718/// Represents a prototype with parameter type info, e.g.
3719/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3720/// parameters, not as having a single void parameter. Such a type can have
3721/// an exception specification, but this specification is not part of the
3722/// canonical type. FunctionProtoType has several trailing objects, some of
3723/// which optional. For more information about the trailing objects see
3724/// the first comment inside FunctionProtoType.
3725class FunctionProtoType final
  : public FunctionType,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<
        FunctionProtoType, QualType, FunctionType::FunctionTypeExtraBitfields,
        FunctionType::ExceptionType, Expr *, FunctionDecl *,
        FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

// FunctionProtoType is followed by several trailing objects, some of
// which optional. They are in order:
//
// * An array of getNumParams() QualType holding the parameter types.
//   Always present. Note that for the vast majority of FunctionProtoType,
//   these will be the only trailing objects.
//
// * Optionally if some extra data is stored in FunctionTypeExtraBitfields
//   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
//   a single FunctionTypeExtraBitfields. Present if and only if
//   hasExtraBitfields() is true.
//
// * Optionally exactly one of:
//   * an array of getNumExceptions() ExceptionType,
//   * a single Expr *,
//   * a pair of FunctionDecl *,
//   * a single FunctionDecl *
//   used to store information about the various types of exception
//   specification. See getExceptionSpecSize for the details.
//
// * Optionally an array of getNumParams() ExtParameterInfo holding
//   an ExtParameterInfo for each of the parameters. Present if and
//   only if hasExtParameterInfos() is true.
//
// * Optionally a Qualifiers object to represent extra qualifiers that can't
//   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
//   if hasExtQualifiers() is true.
//
// The optional FunctionTypeExtraBitfields has to be before the data
// related to the exception specification since it contains the number
// of exception types.
//
// We put the ExtParameterInfos last.  If all were equal, it would make
// more sense to put these before the exception specification, because
// it's much easier to skip past them compared to the elaborate switch
// required to skip the exception specification.  However, all is not
// equal; ExtParameterInfos are used to model very uncommon features,
// and it's better not to burden the more common paths.

3774public:
/// Holds information about the various types of exception specification.
/// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
/// used to group together the various bits of information about the
/// exception specification.
struct ExceptionSpecInfo {
  /// The kind of exception specification this is.
  ExceptionSpecificationType Type = EST_None;

  /// Explicitly-specified list of exception types.
  ArrayRef<QualType> Exceptions;

  /// Noexcept expression, if this is a computed noexcept specification.
  Expr *NoexceptExpr = nullptr;

  /// The function whose exception specification this is, for
  /// EST_Unevaluated and EST_Uninstantiated.
  FunctionDecl *SourceDecl = nullptr;

  /// The function template whose exception specification this is instantiated
  /// from, for EST_Uninstantiated.
  FunctionDecl *SourceTemplate = nullptr;

  ExceptionSpecInfo() = default;

  ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
};

/// Extra information about a function prototype. ExtProtoInfo is not
/// stored as such in FunctionProtoType but is used to group together
/// the various bits of extra information about a function prototype.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  Qualifiers TypeQuals;
  RefQualifierKind RefQualifier = RQ_None;
  ExceptionSpecInfo ExceptionSpec;
  const ExtParameterInfo *ExtParameterInfos = nullptr;

  ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo(CallingConv CC)
      : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = ESI;
    return Result;
  }
};

3826private:
unsigned numTrailingObjects(OverloadToken<QualType>) const {
  return getNumParams();
}

unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
  return hasExtraBitfields();
}

unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
  return getExceptionSpecSize().NumExceptionType;
}

unsigned numTrailingObjects(OverloadToken<Expr *>) const {
  return getExceptionSpecSize().NumExprPtr;
}

unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
  return getExceptionSpecSize().NumFunctionDeclPtr;
}

unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
  return hasExtParameterInfos() ? getNumParams() : 0;
}

/// Determine whether there are any argument types that
/// contain an unexpanded parameter pack.
static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
                                               unsigned numArgs) {
  for (unsigned Idx = 0; Idx < numArgs; ++Idx)
    if (ArgArray[Idx]->containsUnexpandedParameterPack())
      return true;

  return false;
}

FunctionProtoType(QualType result, ArrayRef<QualType> params,
                  QualType canonical, const ExtProtoInfo &epi);

/// This struct is returned by getExceptionSpecSize and is used to
/// translate an ExceptionSpecificationType to the number and kind
/// of trailing objects related to the exception specification.
struct ExceptionSpecSizeHolder {
  unsigned NumExceptionType;
  unsigned NumExprPtr;
  unsigned NumFunctionDeclPtr;
};

/// Return the number and kind of trailing objects
/// related to the exception specification.
static ExceptionSpecSizeHolder
getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
  switch (EST) {
  case EST_None:
  case EST_DynamicNone:
  case EST_MSAny:
  case EST_BasicNoexcept:
  case EST_Unparsed:
  case EST_NoThrow:
    return {0, 0, 0};

  case EST_Dynamic:
    return {NumExceptions, 0, 0};

  case EST_DependentNoexcept:
  case EST_NoexceptFalse:
  case EST_NoexceptTrue:
    return {0, 1, 0};

  case EST_Uninstantiated:
    return {0, 0, 2};

  case EST_Unevaluated:
    return {0, 0, 1};
  }
  llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3901);
}

/// Return the number and kind of trailing objects
/// related to the exception specification.
ExceptionSpecSizeHolder getExceptionSpecSize() const {
  return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
static bool hasExtraBitfields(ExceptionSpecificationType EST) {
  // If the exception spec type is EST_Dynamic then we have > 0 exception
  // types and the exact number is stored in FunctionTypeExtraBitfields.
  return EST == EST_Dynamic;
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
bool hasExtraBitfields() const {
  return hasExtraBitfields(getExceptionSpecType());
}

bool hasExtQualifiers() const {
  return FunctionTypeBits.HasExtQuals;
}

3926public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((i < getNumParams() && "invalid parameter index")
 ? static_cast<void> (0) : __assert_fail ("i < getNumParams() && \"invalid parameter index\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3930, __PRETTY_FUNCTION__));
  return param_type_begin()[i];
}

ArrayRef<QualType> getParamTypes() const {
  return llvm::makeArrayRef(param_type_begin(), param_type_end());
}

ExtProtoInfo getExtProtoInfo() const {
  ExtProtoInfo EPI;
  EPI.ExtInfo = getExtInfo();
  EPI.Variadic = isVariadic();
  EPI.HasTrailingReturn = hasTrailingReturn();
  EPI.ExceptionSpec.Type = getExceptionSpecType();
  EPI.TypeQuals = getMethodQuals();
  EPI.RefQualifier = getRefQualifier();
  if (EPI.ExceptionSpec.Type == EST_Dynamic) {
    EPI.ExceptionSpec.Exceptions = exceptions();
  } else if (isComputedNoexcept(EPI.ExceptionSpec.Type)) {
    EPI.ExceptionSpec.NoexceptExpr = getNoexceptExpr();
  } else if (EPI.ExceptionSpec.Type == EST_Uninstantiated) {
    EPI.ExceptionSpec.SourceDecl = getExceptionSpecDecl();
    EPI.ExceptionSpec.SourceTemplate = getExceptionSpecTemplate();
  } else if (EPI.ExceptionSpec.Type == EST_Unevaluated) {
    EPI.ExceptionSpec.SourceDecl = getExceptionSpecDecl();
  }
  EPI.ExtParameterInfos = getExtParameterInfosOrNull();
  return EPI;
}

/// Get the kind of exception specification on this function.
ExceptionSpecificationType getExceptionSpecType() const {
  return static_cast<ExceptionSpecificationType>(
      FunctionTypeBits.ExceptionSpecType);
}

/// Return whether this function has any kind of exception spec.
bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }

/// Return whether this function has a dynamic (throw) exception spec.
bool hasDynamicExceptionSpec() const {
  return isDynamicExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a noexcept exception spec.
bool hasNoexceptExceptionSpec() const {
  return isNoexceptExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a dependent exception spec.
bool hasDependentExceptionSpec() const;

/// Return whether this function has an instantiation-dependent exception
/// spec.
bool hasInstantiationDependentExceptionSpec() const;

/// Return the number of types in the exception specification.
unsigned getNumExceptions() const {
  return getExceptionSpecType() == EST_Dynamic
             ? getTrailingObjects<FunctionTypeExtraBitfields>()
                   ->NumExceptionType
             : 0;
}

/// Return the ith exception type, where 0 <= i < getNumExceptions().
QualType getExceptionType(unsigned i) const {
  assert(i < getNumExceptions() && "Invalid exception number!")((i < getNumExceptions() && "Invalid exception number!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumExceptions() && \"Invalid exception number!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3996, __PRETTY_FUNCTION__));
  return exception_begin()[i];
}

/// Return the expression inside noexcept(expression), or a null pointer
/// if there is none (because the exception spec is not of this form).
Expr *getNoexceptExpr() const {
  if (!isComputedNoexcept(getExceptionSpecType()))
    return nullptr;
  return *getTrailingObjects<Expr *>();
}

/// If this function type has an exception specification which hasn't
/// been determined yet (either because it has not been evaluated or because
/// it has not been instantiated), this is the function whose exception
/// specification is represented by this type.
FunctionDecl *getExceptionSpecDecl() const {
  if (getExceptionSpecType() != EST_Uninstantiated &&
      getExceptionSpecType() != EST_Unevaluated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[0];
}

/// If this function type has an uninstantiated exception
/// specification, this is the function whose exception specification
/// should be instantiated to find the exception specification for
/// this type.
FunctionDecl *getExceptionSpecTemplate() const {
  if (getExceptionSpecType() != EST_Uninstantiated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow() const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
}

/// Whether this function prototype is variadic.
bool isVariadic() const { return FunctionTypeBits.Variadic; }

/// Determines whether this function prototype contains a
/// parameter pack at the end.
///
/// A function template whose last parameter is a parameter pack can be
/// called with an arbitrary number of arguments, much like a variadic
/// function.
bool isTemplateVariadic() const;

/// Whether this function prototype has a trailing return type.
bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }

Qualifiers getMethodQuals() const {
  if (hasExtQualifiers())
    return *getTrailingObjects<Qualifiers>();
  else
    return getFastTypeQuals();
}

/// Retrieve the ref-qualifier associated with this function type.
RefQualifierKind getRefQualifier() const {
  return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
}

using param_type_iterator = const QualType *;
using param_type_range = llvm::iterator_range<param_type_iterator>;

param_type_range param_types() const {
  return param_type_range(param_type_begin(), param_type_end());
}

param_type_iterator param_type_begin() const {
  return getTrailingObjects<QualType>();
}

param_type_iterator param_type_end() const {
  return param_type_begin() + getNumParams();
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  return reinterpret_cast<exception_iterator>(
      getTrailingObjects<ExceptionType>());
}

exception_iterator exception_end() const {
  return exception_begin() + getNumExceptions();
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const {
  return FunctionTypeBits.HasExtParameterInfos;
}

ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())((hasExtParameterInfos()) ? static_cast<void> (0) : __assert_fail
 ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4103, __PRETTY_FUNCTION__));
  return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
                                    getNumParams());
}

/// Return a pointer to the beginning of the array of extra parameter
/// information, if present, or else null if none of the parameters
/// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
const ExtParameterInfo *getExtParameterInfosOrNull() const {
  if (!hasExtParameterInfos())
    return nullptr;
  return getTrailingObjects<ExtParameterInfo>();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4118, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4125, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4132, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void printExceptionSpecification(raw_ostream &OS,
                                 const PrintingPolicy &Policy) const;

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionProto;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                    param_type_iterator ArgTys, unsigned NumArgs,
                    const ExtProtoInfo &EPI, const ASTContext &Context,
                    bool Canonical);
4153};

4155/// Represents the dependent type named by a dependently-scoped
4156/// typename using declaration, e.g.
4157///   using typename Base<T>::foo;
4158///
4159/// Template instantiation turns these into the underlying type.
4160class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(), true, true, false,
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(const_cast<UnresolvedUsingTypenameDecl*>(D)) {}

4170public:
UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnresolvedUsing;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  return Profile(ID, Decl);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    UnresolvedUsingTypenameDecl *D) {
  ID.AddPointer(D);
}
4188};

4190class TypedefType : public Type {
TypedefNameDecl *Decl;

4193protected:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can)
    : Type(tc, can, can->isDependentType(),
           can->isInstantiationDependentType(),
           can->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(const_cast<TypedefNameDecl*>(D)) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4202, __PRETTY_FUNCTION__));
}

4205public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4212};

4214/// Sugar type that represents a type that was qualified by a qualifier written
4215/// as a macro invocation.
4216class MacroQualifiedType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType UnderlyingTy;
const IdentifierInfo *MacroII;

MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
                   const IdentifierInfo *MacroII)
    : Type(MacroQualified, CanonTy, UnderlyingTy->isDependentType(),
           UnderlyingTy->isInstantiationDependentType(),
           UnderlyingTy->isVariablyModifiedType(),
           UnderlyingTy->containsUnexpandedParameterPack()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4230, __PRETTY_FUNCTION__))
         "Expected a macro qualified type to only wrap attributed types.")((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4230, __PRETTY_FUNCTION__));
}

4233public:
const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
QualType getUnderlyingType() const { return UnderlyingTy; }

/// Return this attributed type's modified type with no qualifiers attached to
/// it.
QualType getModifiedType() const;

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == MacroQualified;
}
4247};

4249/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4250class TypeOfExprType : public Type {
Expr *TOExpr;

4253protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4258public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4268};

4270/// Internal representation of canonical, dependent
4271/// `typeof(expr)` types.
4272///
4273/// This class is used internally by the ASTContext to manage
4274/// canonical, dependent types, only. Clients will only see instances
4275/// of this class via TypeOfExprType nodes.
4276class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4280public:
DependentTypeOfExprType(const ASTContext &Context, Expr *E)
    : TypeOfExprType(E), Context(Context) {}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4290};

4292/// Represents `typeof(type)`, a GCC extension.
4293class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->isDependentType(),
           T->isInstantiationDependentType(),
           T->isVariablyModifiedType(),
           T->containsUnexpandedParameterPack()),
      TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4304, __PRETTY_FUNCTION__));
}

4307public:
QualType getUnderlyingType() const { return TOType; }

/// Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4317};

4319/// Represents the type `decltype(expr)` (C++11).
4320class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4324protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4329public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4340};

4342/// Internal representation of canonical, dependent
4343/// decltype(expr) types.
4344///
4345/// This class is used internally by the ASTContext to manage
4346/// canonical, dependent types, only. Clients will only see instances
4347/// of this class via DecltypeType nodes.
4348class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4351public:
DependentDecltypeType(const ASTContext &Context, Expr *E);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4360};

4362/// A unary type transform, which is a type constructed from another.
4363class UnaryTransformType : public Type {
4364public:
enum UTTKind {
  EnumUnderlyingType
};

4369private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4378protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4384public:
bool isSugared() const { return !isDependentType(); }
QualType desugar() const { return UnderlyingType; }

QualType getUnderlyingType() const { return UnderlyingType; }
QualType getBaseType() const { return BaseType; }

UTTKind getUTTKind() const { return UKind; }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnaryTransform;
}
4396};

4398/// Internal representation of canonical, dependent
4399/// __underlying_type(type) types.
4400///
4401/// This class is used internally by the ASTContext to manage
4402/// canonical, dependent types, only. Clients will only see instances
4403/// of this class via UnaryTransformType nodes.
4404class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4406public:
DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
                            UTTKind UKind);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getBaseType(), getUTTKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                    UTTKind UKind) {
  ID.AddPointer(BaseType.getAsOpaquePtr());
  ID.AddInteger((unsigned)UKind);
}
4419};

4421class TagType : public Type {
friend class ASTReader;

/// Stores the TagDecl associated with this type. The decl may point to any
/// TagDecl that declares the entity.
TagDecl *decl;

4428protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4431public:
TagDecl *getDecl() const;

/// Determines whether this type is in the process of being defined.
bool isBeingDefined() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == Enum || T->getTypeClass() == Record;
}
4440};

4442/// A helper class that allows the use of isa/cast/dyncast
4443/// to detect TagType objects of structs/unions/classes.
4444class RecordType : public TagType {
4445protected:
friend class ASTContext; // ASTContext creates these.

explicit RecordType(const RecordDecl *D)
    : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
explicit RecordType(TypeClass TC, RecordDecl *D)
    : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4453public:
RecordDecl *getDecl() const {
  return reinterpret_cast<RecordDecl*>(TagType::getDecl());
}

/// Recursively check all fields in the record for const-ness. If any field
/// is declared const, return true. Otherwise, return false.
bool hasConstFields() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4466};

4468/// A helper class that allows the use of isa/cast/dyncast
4469/// to detect TagType objects of enums.
4470class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4476public:
EnumDecl *getDecl() const {
  return reinterpret_cast<EnumDecl*>(TagType::getDecl());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4485};

4487/// An attributed type is a type to which a type attribute has been applied.
4488///
4489/// The "modified type" is the fully-sugared type to which the attributed
4490/// type was applied; generally it is not canonically equivalent to the
4491/// attributed type. The "equivalent type" is the minimally-desugared type
4492/// which the type is canonically equivalent to.
4493///
4494/// For example, in the following attributed type:
4495///     int32_t __attribute__((vector_size(16)))
4496///   - the modified type is the TypedefType for int32_t
4497///   - the equivalent type is VectorType(16, int32_t)
4498///   - the canonical type is VectorType(16, int)
4499class AttributedType : public Type, public llvm::FoldingSetNode {
4500public:
using Kind = attr::Kind;

4503private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->isDependentType(),
           equivalent->isInstantiationDependentType(),
           equivalent->isVariablyModifiedType(),
           equivalent->containsUnexpandedParameterPack()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4519public:
Kind getAttrKind() const {
  return static_cast<Kind>(AttributedTypeBits.AttrKind);
}

QualType getModifiedType() const { return ModifiedType; }
QualType getEquivalentType() const { return EquivalentType; }

bool isSugared() const { return true; }
QualType desugar() const { return getEquivalentType(); }

/// Does this attribute behave like a type qualifier?
///
/// A type qualifier adjusts a type to provide specialized rules for
/// a specific object, like the standard const and volatile qualifiers.
/// This includes attributes controlling things like nullability,
/// address spaces, and ARC ownership.  The value of the object is still
/// largely described by the modified type.
///
/// In contrast, many type attributes "rewrite" their modified type to
/// produce a fundamentally different type, not necessarily related in any
/// formalizable way to the original type.  For example, calling convention
/// and vector attributes are not simple type qualifiers.
///
/// Type qualifiers are often, but not always, reflected in the canonical
/// type.
bool isQualifier() const;

bool isMSTypeSpec() const;

bool isCallingConv() const;

llvm::Optional<NullabilityKind> getImmediateNullability() const;

/// Retrieve the attribute kind corresponding to the given
/// nullability kind.
static Kind getNullabilityAttrKind(NullabilityKind kind) {
  switch (kind) {
  case NullabilityKind::NonNull:
    return attr::TypeNonNull;

  case NullabilityKind::Nullable:
    return attr::TypeNullable;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4566);
}

/// Strip off the top-level nullability annotation on the given
/// type, if it's there.
///
/// \param T The type to strip. If the type is exactly an
/// AttributedType specifying nullability (without looking through
/// type sugar), the nullability is returned and this type changed
/// to the underlying modified type.
///
/// \returns the top-level nullability, if present.
static Optional<NullabilityKind> stripOuterNullability(QualType &T);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
}

static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
                    QualType modified, QualType equivalent) {
  ID.AddInteger(attrKind);
  ID.AddPointer(modified.getAsOpaquePtr());
  ID.AddPointer(equivalent.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}
4594};

4596class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

// Helper data collector for canonical types.
struct CanonicalTTPTInfo {
  unsigned Depth : 15;
  unsigned ParameterPack : 1;
  unsigned Index : 16;
};

union {
  // Info for the canonical type.
  CanonicalTTPTInfo CanTTPTInfo;

  // Info for the non-canonical type.
  TemplateTypeParmDecl *TTPDecl;
};

/// Build a non-canonical type.
TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
    : Type(TemplateTypeParm, Canon, /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false,
           Canon->containsUnexpandedParameterPack()),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false, PP) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4638public:
unsigned getDepth() const { return getCanTTPTInfo().Depth; }
unsigned getIndex() const { return getCanTTPTInfo().Index; }
bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }

TemplateTypeParmDecl *getDecl() const {
  return isCanonicalUnqualified() ? nullptr : TTPDecl;
}

IdentifierInfo *getIdentifier() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
                    unsigned Index, bool ParameterPack,
                    TemplateTypeParmDecl *TTPDecl) {
  ID.AddInteger(Depth);
  ID.AddInteger(Index);
  ID.AddBoolean(ParameterPack);
  ID.AddPointer(TTPDecl);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateTypeParm;
}
4668};

4670/// Represents the result of substituting a type for a template
4671/// type parameter.
4672///
4673/// Within an instantiated template, all template type parameters have
4674/// been replaced with these.  They are used solely to record that a
4675/// type was originally written as a template type parameter;
4676/// therefore they are never canonical.
4677class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

// The original type parameter.
const TemplateTypeParmType *Replaced;

SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
    : Type(SubstTemplateTypeParm, Canon, Canon->isDependentType(),
           Canon->isInstantiationDependentType(),
           Canon->isVariablyModifiedType(),
           Canon->containsUnexpandedParameterPack()),
      Replaced(Param) {}

4690public:
/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

/// Gets the type that was substituted for the template
/// parameter.
QualType getReplacementType() const {
  return getCanonicalTypeInternal();
}

bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReplacedParameter(), getReplacementType());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    QualType Replacement) {
  ID.AddPointer(Replaced);
  ID.AddPointer(Replacement.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParm;
}
4719};

4721/// Represents the result of substituting a set of types for a template
4722/// type parameter pack.
4723///
4724/// When a pack expansion in the source code contains multiple parameter packs
4725/// and those parameter packs correspond to different levels of template
4726/// parameter lists, this type node is used to represent a template type
4727/// parameter pack from an outer level, which has already had its argument pack
4728/// substituted but that still lives within a pack expansion that itself
4729/// could not be instantiated. When actually performing a substitution into
4730/// that pack expansion (e.g., when all template parameters have corresponding
4731/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4732/// at the current pack substitution index.
4733class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// The original type parameter.
const TemplateTypeParmType *Replaced;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4747public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

unsigned getNumArgs() const {
  return SubstTemplateTypeParmPackTypeBits.NumArgs;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

TemplateArgument getArgumentPack() const;

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    const TemplateArgument &ArgPack);

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParmPack;
}
4772};

4774/// Common base class for placeholders for types that get replaced by
4775/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4776/// class template types, and (eventually) constrained type names from the C++
4777/// Concepts TS.
4778///
4779/// These types are usually a placeholder for a deduced type. However, before
4780/// the initializer is attached, or (usually) if the initializer is
4781/// type-dependent, there is no deduced type and the type is canonical. In
4782/// the latter case, it is also a dependent type.
4783class DeducedType : public Type {
4784protected:
DeducedType(TypeClass TC, QualType DeducedAsType, bool IsDependent,
            bool IsInstantiationDependent, bool ContainsParameterPack)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           IsDependent, IsInstantiationDependent,
           /*VariablyModified=*/false, ContainsParameterPack) {
  if (!DeducedAsType.isNull()) {
    if (DeducedAsType->isDependentType())
      setDependent();
    if (DeducedAsType->isInstantiationDependentType())
      setInstantiationDependent();
    if (DeducedAsType->containsUnexpandedParameterPack())
      setContainsUnexpandedParameterPack();
  }
}

4803public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// Get the type deduced for this placeholder type, or null if it's
/// either not been deduced or was deduced to a dependent type.
QualType getDeducedType() const {
  return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
}
bool isDeduced() const {
  return !isCanonicalUnqualified() || isDependentType();
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto ||
         T->getTypeClass() == DeducedTemplateSpecialization;
}
4820};

4822/// Represents a C++11 auto or C++14 decltype(auto) type.
4823class AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         bool IsDeducedAsDependent, bool IsDeducedAsPack)
    : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent,
                  IsDeducedAsDependent, IsDeducedAsPack) {
  AutoTypeBits.Keyword = (unsigned)Keyword;
}

4833public:
bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDeducedType(), getKeyword(), isDependentType(),
          containsUnexpandedParameterPack());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced,
                    AutoTypeKeyword Keyword, bool IsDependent, bool IsPack) {
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddInteger((unsigned)Keyword);
  ID.AddBoolean(IsDependent);
  ID.AddBoolean(IsPack);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
4858};

4860/// Represents a C++17 deduced template specialization type.
4861class DeducedTemplateSpecializationType : public DeducedType,
                                        public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template whose arguments will be deduced.
TemplateName Template;

DeducedTemplateSpecializationType(TemplateName Template,
                                  QualType DeducedAsType,
                                  bool IsDeducedAsDependent)
    : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                  IsDeducedAsDependent || Template.isDependent(),
                  IsDeducedAsDependent || Template.isInstantiationDependent(),
                  Template.containsUnexpandedParameterPack()),
      Template(Template) {}

4877public:
/// Retrieve the name of the template that we are deducing.
TemplateName getTemplateName() const { return Template;}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
                    QualType Deduced, bool IsDependent) {
  Template.Profile(ID);
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DeducedTemplateSpecialization;
}
4895};

4897/// Represents a type template specialization; the template
4898/// must be a class template, a type alias template, or a template
4899/// template parameter.  A template which cannot be resolved to one of
4900/// these, e.g. because it is written with a dependent scope
4901/// specifier, is instead represented as a
4902/// @c DependentTemplateSpecializationType.
4903///
4904/// A non-dependent template specialization type is always "sugar",
4905/// typically for a \c RecordType.  For example, a class template
4906/// specialization type of \c vector<int> will refer to a tag type for
4907/// the instantiation \c std::vector<int, std::allocator<int>>
4908///
4909/// Template specializations are dependent if either the template or
4910/// any of the template arguments are dependent, in which case the
4911/// type may also be canonical.
4912///
4913/// Instances of this type are allocated with a trailing array of
4914/// TemplateArguments, followed by a QualType representing the
4915/// non-canonical aliased type when the template is a type alias
4916/// template.
4917class alignas(8) TemplateSpecializationType
  : public Type,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template being specialized.  This is
/// either a TemplateName::Template (in which case it is a
/// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
/// TypeAliasTemplateDecl*), a
/// TemplateName::SubstTemplateTemplateParmPack, or a
/// TemplateName::SubstTemplateTemplateParm (in which case the
/// replacement must, recursively, be one of these).
TemplateName Template;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

4936public:
/// Determine whether any of the given template arguments are dependent.
static bool anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                                          bool &InstantiationDependent);

static bool anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                                          bool &InstantiationDependent);

/// True if this template specialization type matches a current
/// instantiation in the context in which it is found.
bool isCurrentInstantiation() const {
  return isa<InjectedClassNameType>(getCanonicalTypeInternal());
}

/// Determine if this template specialization type is for a type alias
/// template that has been substituted.
///
/// Nearly every template specialization type whose template is an alias
/// template will be substituted. However, this is not the case when
/// the specialization contains a pack expansion but the template alias
/// does not have a corresponding parameter pack, e.g.,
///
/// \code
/// template<typename T, typename U, typename V> struct S;
/// template<typename T, typename U> using A = S<T, int, U>;
/// template<typename... Ts> struct X {
///   typedef A<Ts...> type; // not a type alias
/// };
/// \endcode
bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }

/// Get the aliased type, if this is a specialization of a type alias
/// template.
QualType getAliasedType() const {
  assert(isTypeAlias() && "not a type alias template specialization")((isTypeAlias() && "not a type alias template specialization"
) ? static_cast<void> (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4970, __PRETTY_FUNCTION__));
  return *reinterpret_cast<const QualType*>(end());
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // defined inline in TemplateBase.h

/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return reinterpret_cast<const TemplateArgument *>(this + 1);
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return TemplateSpecializationTypeBits.NumArgs;
}

/// Retrieve a specific template argument as a type.
/// \pre \c isArgType(Arg)
const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const {
  return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Template, template_arguments(), Ctx);
  if (isTypeAlias())
    getAliasedType().Profile(ID);
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                    ArrayRef<TemplateArgument> Args,
                    const ASTContext &Context);

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateSpecialization;
}
5021};

5023/// Print a template argument list, including the '<' and '>'
5024/// enclosing the template arguments.
5025void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy);

5029void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy);

5033void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy);

5037/// The injected class name of a C++ class template or class
5038/// template partial specialization.  Used to record that a type was
5039/// spelled with a bare identifier rather than as a template-id; the
5040/// equivalent for non-templated classes is just RecordType.
5041///
5042/// Injected class name types are always dependent.  Template
5043/// instantiation turns these into RecordTypes.
5044///
5045/// Injected class name types are always canonical.  This works
5046/// because it is impossible to compare an injected class name type
5047/// with the corresponding non-injected template type, for the same
5048/// reason that it is impossible to directly compare template
5049/// parameters from different dependent contexts: injected class name
5050/// types can only occur within the scope of a particular templated
5051/// declaration, and within that scope every template specialization
5052/// will canonicalize to the injected class name (when appropriate
5053/// according to the rules of the language).
5054class InjectedClassNameType : public Type {
friend class ASTContext; // ASTContext creates these.
friend class ASTNodeImporter;
friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                        // currently suitable for AST reading, too much
                        // interdependencies.

CXXRecordDecl *Decl;

/// The template specialization which this type represents.
/// For example, in
///   template <class T> class A { ... };
/// this is A<T>, whereas in
///   template <class X, class Y> class A<B<X,Y> > { ... };
/// this is A<B<X,Y> >.
///
/// It is always unqualified, always a template specialization type,
/// and always dependent.
QualType InjectedType;

InjectedClassNameType(CXXRecordDecl *D, QualType TST)
    : Type(InjectedClassName, QualType(), /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false,
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))((isa<TemplateSpecializationType>(TST)) ? static_cast<
void> (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5080, __PRETTY_FUNCTION__));
  assert(!TST.hasQualifiers())((!TST.hasQualifiers()) ? static_cast<void> (0) : __assert_fail
 ("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5081, __PRETTY_FUNCTION__));
  assert(TST->isDependentType())((TST->isDependentType()) ? static_cast<void> (0) : __assert_fail
 ("TST->isDependentType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5082, __PRETTY_FUNCTION__));
}

5085public:
QualType getInjectedSpecializationType() const { return InjectedType; }

const TemplateSpecializationType *getInjectedTST() const {
  return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
}

TemplateName getTemplateName() const {
  return getInjectedTST()->getTemplateName();
}

CXXRecordDecl *getDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == InjectedClassName;
}
5104};

5106/// The kind of a tag type.
5107enum TagTypeKind {
/// The "struct" keyword.
TTK_Struct,

/// The "__interface" keyword.
TTK_Interface,

/// The "union" keyword.
TTK_Union,

/// The "class" keyword.
TTK_Class,

/// The "enum" keyword.
TTK_Enum
5122};

5124/// The elaboration keyword that precedes a qualified type name or
5125/// introduces an elaborated-type-specifier.
5126enum ElaboratedTypeKeyword {
/// The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// No keyword precedes the qualified type name.
ETK_None
5148};

5150/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5151/// The keyword in stored in the free bits of the base class.
5152/// Also provides a few static helpers for converting and printing
5153/// elaborated type keyword and tag type kind enumerations.
5154class TypeWithKeyword : public Type {
5155protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, bool Dependent,
                bool InstantiationDependent, bool VariablyModified,
                bool ContainsUnexpandedParameterPack)
    : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
           ContainsUnexpandedParameterPack) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5165public:
ElaboratedTypeKeyword getKeyword() const {
  return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
}

/// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);

/// Converts a type specifier (DeclSpec::TST) into a tag type kind.
/// It is an error to provide a type specifier which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);

/// Converts a TagTypeKind into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);

/// Converts an elaborated type keyword into a TagTypeKind.
/// It is an error to provide an elaborated type keyword
/// which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);

static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);

static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);

static StringRef getTagTypeKindName(TagTypeKind Kind) {
  return getKeywordName(getKeywordForTagTypeKind(Kind));
}

class CannotCastToThisType {};
static CannotCastToThisType classof(const Type *);
5195};

5197/// Represents a type that was referred to using an elaborated type
5198/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5199/// or both.
5200///
5201/// This type is used to keep track of a type name as written in the
5202/// source code, including tag keywords and any nested-name-specifiers.
5203/// The type itself is always "sugar", used to express what was written
5204/// in the source code but containing no additional semantic information.
5205class ElaboratedType final
  : public TypeWithKeyword,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
friend class ASTContext; // ASTContext creates these
friend TrailingObjects;

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

/// The (re)declaration of this tag type owned by this occurrence is stored
/// as a trailing object if there is one. Use getOwnedTagDecl to obtain
/// it, or obtain a null pointer if there is none.

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
    : TypeWithKeyword(Keyword, Elaborated, CanonType,
                      NamedType->isDependentType(),
                      NamedType->isInstantiationDependentType(),
                      NamedType->isVariablyModifiedType(),
                      NamedType->containsUnexpandedParameterPack()),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5237, __PRETTY_FUNCTION__))
         "ElaboratedType cannot have elaborated type keyword "((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5237, __PRETTY_FUNCTION__))
         "and name qualifier both null.")((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5237, __PRETTY_FUNCTION__));
}

5240public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the qualified-id.
QualType getNamedType() const { return NamedType; }

/// Remove a single level of sugar.
QualType desugar() const { return getNamedType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if there is none.
TagDecl *getOwnedTagDecl() const {
  return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
                                            : nullptr;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType,
                    TagDecl *OwnedTagDecl) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
  ID.AddPointer(OwnedTagDecl);
}

static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5274};

5276/// Represents a qualified type name for which the type name is
5277/// dependent.
5278///
5279/// DependentNameType represents a class of dependent types that involve a
5280/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5281/// name of a type. The DependentNameType may start with a "typename" (for a
5282/// typename-specifier), "class", "struct", "union", or "enum" (for a
5283/// dependent elaborated-type-specifier), or nothing (in contexts where we
5284/// know that we must be referring to a type, e.g., in a base class specifier).
5285/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5286/// mode, this type is used with non-dependent names to delay name lookup until
5287/// instantiation.
5288class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this typename specifier refers to.
const IdentifierInfo *Name;

DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
                  const IdentifierInfo *Name, QualType CanonType)
    : TypeWithKeyword(Keyword, DependentName, CanonType, /*Dependent=*/true,
                      /*InstantiationDependent=*/true,
                      /*VariablyModified=*/false,
                      NNS->containsUnexpandedParameterPack()),
      NNS(NNS), Name(Name) {}

5305public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the typename specifier as an identifier.
///
/// This routine will return a non-NULL identifier pointer when the
/// form of the original typename was terminated by an identifier,
/// e.g., "typename T::type".
const IdentifierInfo *getIdentifier() const {
  return Name;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, Name);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  ID.AddPointer(Name);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentName;
}
5335};

5337/// Represents a template specialization type whose template cannot be
5338/// resolved, e.g.
5339///   A<T>::template B<T>
5340class alignas(8) DependentTemplateSpecializationType
  : public TypeWithKeyword,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The identifier of the template.
const IdentifierInfo *Name;

DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                    NestedNameSpecifier *NNS,
                                    const IdentifierInfo *Name,
                                    ArrayRef<TemplateArgument> Args,
                                    QualType Canon);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

5365public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return DependentTemplateSpecializationTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // inline in TemplateBase.h

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const ASTContext &Context,
                    ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *Qualifier,
                    const IdentifierInfo *Name,
                    ArrayRef<TemplateArgument> Args);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentTemplateSpecialization;
}
5407};

5409/// Represents a pack expansion of types.
5410///
5411/// Pack expansions are part of C++11 variadic templates. A pack
5412/// expansion contains a pattern, which itself contains one or more
5413/// "unexpanded" parameter packs. When instantiated, a pack expansion
5414/// produces a series of types, each instantiated from the pattern of
5415/// the expansion, where the Ith instantiation of the pattern uses the
5416/// Ith arguments bound to each of the unexpanded parameter packs. The
5417/// pack expansion is considered to "expand" these unexpanded
5418/// parameter packs.
5419///
5420/// \code
5421/// template<typename ...Types> struct tuple;
5422///
5423/// template<typename ...Types>
5424/// struct tuple_of_references {
5425///   typedef tuple<Types&...> type;
5426/// };
5427/// \endcode
5428///
5429/// Here, the pack expansion \c Types&... is represented via a
5430/// PackExpansionType whose pattern is Types&.
5431class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The pattern of the pack expansion.
QualType Pattern;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(),
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/Pattern->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5448public:
/// Retrieve the pattern of this pack expansion, which is the
/// type that will be repeatedly instantiated when instantiating the
/// pack expansion itself.
QualType getPattern() const { return Pattern; }

/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (PackExpansionTypeBits.NumExpansions)
    return PackExpansionTypeBits.NumExpansions - 1;
  return None;
}

bool isSugared() const { return !Pattern->isDependentType(); }
QualType desugar() const { return isSugared() ? Pattern : QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPattern(), getNumExpansions());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
                    Optional<unsigned> NumExpansions) {
  ID.AddPointer(Pattern.getAsOpaquePtr());
  ID.AddBoolean(NumExpansions.hasValue());
  if (NumExpansions)
    ID.AddInteger(*NumExpansions);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == PackExpansion;
}
5480};

5482/// This class wraps the list of protocol qualifiers. For types that can
5483/// take ObjC protocol qualifers, they can subclass this class.
5484template <class T>
5485class ObjCProtocolQualifiers {
5486protected:
ObjCProtocolQualifiers() = default;

ObjCProtocolDecl * const *getProtocolStorage() const {
  return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
}

ObjCProtocolDecl **getProtocolStorage() {
  return static_cast<T*>(this)->getProtocolStorageImpl();
}

void setNumProtocols(unsigned N) {
  static_cast<T*>(this)->setNumProtocolsImpl(N);
}

void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
  setNumProtocols(protocols.size());
  assert(getNumProtocols() == protocols.size() &&((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5504, __PRETTY_FUNCTION__))
         "bitfield overflow in protocol count")((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5504, __PRETTY_FUNCTION__));
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5510public:
using qual_iterator = ObjCProtocolDecl * const *;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
qual_iterator qual_begin() const { return getProtocolStorage(); }
qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }

bool qual_empty() const { return getNumProtocols() == 0; }

/// Return the number of qualifying protocols in this type, or 0 if
/// there are none.
unsigned getNumProtocols() const {
  return static_cast<const T*>(this)->getNumProtocolsImpl();
}

/// Fetch a protocol by index.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  assert(I < getNumProtocols() && "Out-of-range protocol access")((I < getNumProtocols() && "Out-of-range protocol access"
) ? static_cast<void> (0) : __assert_fail ("I < getNumProtocols() && \"Out-of-range protocol access\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5528, __PRETTY_FUNCTION__));
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5536};

5538/// Represents a type parameter type in Objective C. It can take
5539/// a list of protocols.
5540class ObjCTypeParamType : public Type,
                        public ObjCProtocolQualifiers<ObjCTypeParamType>,
                        public llvm::FoldingSetNode {
friend class ASTContext;
friend class ObjCProtocolQualifiers<ObjCTypeParamType>;

/// The number of protocols stored on this type.
unsigned NumProtocols : 6;

ObjCTypeParamDecl *OTPDecl;

/// The protocols are stored after the ObjCTypeParamType node. In the
/// canonical type, the list of protocols are sorted alphabetically
/// and uniqued.
ObjCProtocolDecl **getProtocolStorageImpl();

/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return NumProtocols;
}

void setNumProtocolsImpl(unsigned N) {
  NumProtocols = N;
}

ObjCTypeParamType(const ObjCTypeParamDecl *D,
                  QualType can,
                  ArrayRef<ObjCProtocolDecl *> protocols);

5570public:
bool isSugared() const { return true; }
QualType desugar() const { return getCanonicalTypeInternal(); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCTypeParam;
}

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const ObjCTypeParamDecl *OTPDecl,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5584};

5586/// Represents a class type in Objective C.
5587///
5588/// Every Objective C type is a combination of a base type, a set of
5589/// type arguments (optional, for parameterized classes) and a list of
5590/// protocols.
5591///
5592/// Given the following declarations:
5593/// \code
5594///   \@class C<T>;
5595///   \@protocol P;
5596/// \endcode
5597///
5598/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5599/// with base C and no protocols.
5600///
5601/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5602/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5603/// protocol list.
5604/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5605/// and protocol list [P].
5606///
5607/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5608/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5609/// and no protocols.
5610///
5611/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5612/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5613/// this should get its own sugar class to better represent the source.
5614class ObjCObjectType : public Type,
                     public ObjCProtocolQualifiers<ObjCObjectType> {
friend class ObjCProtocolQualifiers<ObjCObjectType>;

// ObjCObjectType.NumTypeArgs - the number of type arguments stored
// after the ObjCObjectPointerType node.
// ObjCObjectType.NumProtocols - the number of protocols stored
// after the type arguments of ObjCObjectPointerType node.
//
// These protocols are those written directly on the type.  If
// protocol qualifiers ever become additive, the iterators will need
// to get kindof complicated.
//
// In the canonical object type, these are sorted alphabetically
// and uniqued.

/// Either a BuiltinType or an InterfaceType or sugar for either.
QualType BaseType;

/// Cached superclass type.
mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
  CachedSuperClassType;

QualType *getTypeArgStorage();
const QualType *getTypeArgStorage() const {
  return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
}

ObjCProtocolDecl **getProtocolStorageImpl();
/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return ObjCObjectTypeBits.NumProtocols;
}
void setNumProtocolsImpl(unsigned N) {
  ObjCObjectTypeBits.NumProtocols = N;
}

5652protected:
enum Nonce_ObjCInterface { Nonce_ObjCInterface };

ObjCObjectType(QualType Canonical, QualType Base,
               ArrayRef<QualType> typeArgs,
               ArrayRef<ObjCProtocolDecl *> protocols,
               bool isKindOf);

ObjCObjectType(enum Nonce_ObjCInterface)
      : Type(ObjCInterface, QualType(), false, false, false, false),
        BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5670public:
/// Gets the base type of this object type.  This is always (possibly
/// sugar for) one of:
///  - the 'id' builtin type (as opposed to the 'id' type visible to the
///    user, which is a typedef for an ObjCObjectPointerType)
///  - the 'Class' builtin type (same caveat)
///  - an ObjCObjectType (currently always an ObjCInterfaceType)
QualType getBaseType() const { return BaseType; }

bool isObjCId() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
}

bool isObjCClass() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
}

bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
bool isObjCUnqualifiedIdOrClass() const {
  if (!qual_empty()) return false;
  if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
    return T->getKind() == BuiltinType::ObjCId ||
           T->getKind() == BuiltinType::ObjCClass;
  return false;
}
bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }

/// Gets the interface declaration for this object type, if the base type
/// really is an interface.
ObjCInterfaceDecl *getInterface() const;

/// Determine whether this object type is "specialized", meaning
/// that it has type arguments.
bool isSpecialized() const;

/// Determine whether this object type was written with type arguments.
bool isSpecializedAsWritten() const {
  return ObjCObjectTypeBits.NumTypeArgs > 0;
}

/// Determine whether this object type is "unspecialized", meaning
/// that it has no type arguments.
bool isUnspecialized() const { return !isSpecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments of this object type (semantically).
ArrayRef<QualType> getTypeArgs() const;

/// Retrieve the type arguments of this object type as they were
/// written.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return llvm::makeArrayRef(getTypeArgStorage(),
                            ObjCObjectTypeBits.NumTypeArgs);
}

/// Whether this is a "__kindof" type as written.
bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }

/// Whether this ia a "__kindof" type (semantically).
bool isKindOfType() const;

/// Retrieve the type of the superclass of this object type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// specialization of the superclass type. Produces a null type if
/// there is no superclass.
QualType getSuperClassType() const {
  if (!CachedSuperClassType.getInt())
    computeSuperClassTypeSlow();

  assert(CachedSuperClassType.getInt() && "Superclass not set?")((CachedSuperClassType.getInt() && "Superclass not set?"
) ? static_cast<void> (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5746, __PRETTY_FUNCTION__));
  return QualType(CachedSuperClassType.getPointer(), 0);
}

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObject ||
         T->getTypeClass() == ObjCInterface;
}
5761};

5763/// A class providing a concrete implementation
5764/// of ObjCObjectType, so as to not increase the footprint of
5765/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5766/// system should not reference this type.
5767class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
friend class ASTContext;

// If anyone adds fields here, ObjCObjectType::getProtocolStorage()
// will need to be modified.

ObjCObjectTypeImpl(QualType Canonical, QualType Base,
                   ArrayRef<QualType> typeArgs,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   bool isKindOf)
    : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}

5779public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5786};

5788inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5790}

5792inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5795}

5797inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
5800}

5802/// Interfaces are the core concept in Objective-C for object oriented design.
5803/// They basically correspond to C++ classes.  There are two kinds of interface
5804/// types: normal interfaces like `NSString`, and qualified interfaces, which
5805/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
5806///
5807/// ObjCInterfaceType guarantees the following properties when considered
5808/// as a subtype of its superclass, ObjCObjectType:
5809///   - There are no protocol qualifiers.  To reinforce this, code which
5810///     tries to invoke the protocol methods via an ObjCInterfaceType will
5811///     fail to compile.
5812///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
5813///     T->getBaseType() == QualType(T, 0).
5814class ObjCInterfaceType : public ObjCObjectType {
friend class ASTContext; // ASTContext creates these.
friend class ASTReader;
friend class ObjCInterfaceDecl;

mutable ObjCInterfaceDecl *Decl;

ObjCInterfaceType(const ObjCInterfaceDecl *D)
    : ObjCObjectType(Nonce_ObjCInterface),
      Decl(const_cast<ObjCInterfaceDecl*>(D)) {}

5825public:
/// Get the declaration of this interface.
ObjCInterfaceDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCInterface;
}

// Nonsense to "hide" certain members of ObjCObjectType within this
// class.  People asking for protocols on an ObjCInterfaceType are
// not going to get what they want: ObjCInterfaceTypes are
// guaranteed to have no protocols.
enum {
  qual_iterator,
  qual_begin,
  qual_end,
  getNumProtocols,
  getProtocol
};
5847};

5849inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
5859}

5861/// Represents a pointer to an Objective C object.
5862///
5863/// These are constructed from pointer declarators when the pointee type is
5864/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
5865/// types are typedefs for these, and the protocol-qualified types 'id<P>'
5866/// and 'Class<P>' are translated into these.
5867///
5868/// Pointers to pointers to Objective C objects are still PointerTypes;
5869/// only the first level of pointer gets it own type implementation.
5870class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical,
           Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

5883public:
/// Gets the type pointed to by this ObjC pointer.
/// The result will always be an ObjCObjectType or sugar thereof.
QualType getPointeeType() const { return PointeeType; }

/// Gets the type pointed to by this ObjC pointer.  Always returns non-null.
///
/// This method is equivalent to getPointeeType() except that
/// it discards any typedefs (or other sugar) between this
/// type and the "outermost" object type.  So for:
/// \code
///   \@class A; \@protocol P; \@protocol Q;
///   typedef A<P> AP;
///   typedef A A1;
///   typedef A1<P> A1P;
///   typedef A1P<Q> A1PQ;
/// \endcode
/// For 'A*', getObjectType() will return 'A'.
/// For 'A<P>*', getObjectType() will return 'A<P>'.
/// For 'AP*', getObjectType() will return 'A<P>'.
/// For 'A1*', getObjectType() will return 'A'.
/// For 'A1<P>*', getObjectType() will return 'A1<P>'.
/// For 'A1P*', getObjectType() will return 'A1<P>'.
/// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
///   adding protocols to a protocol-qualified base discards the
///   old qualifiers (for now).  But if it didn't, getObjectType()
///   would return 'A1P<Q>' (and we'd have to make iterating over
///   qualifiers more complicated).
const ObjCObjectType *getObjectType() const {
  return PointeeType->castAs<ObjCObjectType>();
}

/// If this pointer points to an Objective C
/// \@interface type, gets the type for that interface.  Any protocol
/// qualifiers on the interface are ignored.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
const ObjCInterfaceType *getInterfaceType() const;

/// If this pointer points to an Objective \@interface
/// type, gets the declaration for that interface.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
ObjCInterfaceDecl *getInterfaceDecl() const {
  return getObjectType()->getInterface();
}

/// True if this is equivalent to the 'id' type, i.e. if
/// its object type is the primitive 'id' type with no protocols.
bool isObjCIdType() const {
  return getObjectType()->isObjCUnqualifiedId();
}

/// True if this is equivalent to the 'Class' type,
/// i.e. if its object tive is the primitive 'Class' type with no protocols.
bool isObjCClassType() const {
  return getObjectType()->isObjCUnqualifiedClass();
}

/// True if this is equivalent to the 'id' or 'Class' type,
bool isObjCIdOrClassType() const {
  return getObjectType()->isObjCUnqualifiedIdOrClass();
}

/// True if this is equivalent to 'id<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedIdType() const {
  return getObjectType()->isObjCQualifiedId();
}

/// True if this is equivalent to 'Class<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedClassType() const {
  return getObjectType()->isObjCQualifiedClass();
}

/// Whether this is a "__kindof" type.
bool isKindOfType() const { return getObjectType()->isKindOfType(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecialized() const { return getObjectType()->isSpecialized(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecializedAsWritten() const {
  return getObjectType()->isSpecializedAsWritten();
}

/// Whether this type is unspecialized, meaning that is has no type arguments.
bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgs() const {
  return getObjectType()->getTypeArgs();
}

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return getObjectType()->getTypeArgsAsWritten();
}

/// An iterator over the qualifiers on the object type.  Provided
/// for convenience.  This will always iterate over the full set of
/// protocols on a type, not just those provided directly.
using qual_iterator = ObjCObjectType::qual_iterator;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }

qual_iterator qual_begin() const {
  return getObjectType()->qual_begin();
}

qual_iterator qual_end() const {
  return getObjectType()->qual_end();
}

bool qual_empty() const { return getObjectType()->qual_empty(); }

/// Return the number of qualifying protocols on the object type.
unsigned getNumProtocols() const {
  return getObjectType()->getNumProtocols();
}

/// Retrieve a qualifying protocol by index on the object type.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  return getObjectType()->getProtocol(I);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Retrieve the type of the superclass of this object pointer type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// pointer to a specialization of the superclass type. Produces a
/// null type if there is no superclass.
QualType getSuperClassType() const;

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
                               const ASTContext &ctx) const;

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObjectPointer;
}
6042};

6044class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->isDependentType(),
           ValTy->isInstantiationDependentType(),
           ValTy->isVariablyModifiedType(),
           ValTy->containsUnexpandedParameterPack()),
      ValueType(ValTy) {}

6056public:
/// Gets the type contained by this atomic type, i.e.
/// the type returned by performing an atomic load of this atomic type.
QualType getValueType() const { return ValueType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getValueType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Atomic;
}
6075};

6077/// PipeType - OpenCL20.
6078class PipeType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;
bool isRead;

PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
    : Type(Pipe, CanonicalPtr, elemType->isDependentType(),
           elemType->isInstantiationDependentType(),
           elemType->isVariablyModifiedType(),
           elemType->containsUnexpandedParameterPack()),
      ElementType(elemType), isRead(isRead) {}

6091public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }

QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), isReadOnly());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
  ID.AddPointer(T.getAsOpaquePtr());
  ID.AddBoolean(isRead);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Pipe;
}

bool isReadOnly() const { return isRead; }
6112};

6114/// A qualifier set is used to build a set of qualifiers.
6115class QualifierCollector : public Qualifiers {
6116public:
QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}

/// Collect any qualifiers on the given type and return an
/// unqualified type.  The qualifiers are assumed to be consistent
/// with those already in the type.
const Type *strip(QualType type) {
  addFastQualifiers(type.getLocalFastQualifiers());
  if (!type.hasLocalNonFastQualifiers())
    return type.getTypePtrUnsafe();

  const ExtQuals *extQuals = type.getExtQualsUnsafe();
  addConsistentQualifiers(extQuals->getQualifiers());
  return extQuals->getBaseType();
}

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, QualType QT) const;

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, const Type* T) const;
6137};

6139// Inline function definitions.

6141inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6146}

6148inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6150}

6152inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6154}

6156inline SplitQualType QualType::split() const {
if (!hasLocalNonFastQualifiers())
  return SplitQualType(getTypePtrUnsafe(),
                       Qualifiers::fromFastMask(getLocalFastQualifiers()));

const ExtQuals *eq = getExtQualsUnsafe();
Qualifiers qs = eq->getQualifiers();
qs.addFastQualifiers(getLocalFastQualifiers());
return SplitQualType(eq->getBaseType(), qs);
6165}

6167inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6173}

6175inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6179}

6181inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6185}

6187inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6190}

6192inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6194}

6196inline bool QualType::isCanonicalAsParam() const {
if (!isCanonical()) return false;
if (hasLocalQualifiers()) return false;

const Type *T = getTypePtr();
if (T->isVariablyModifiedType() && T->hasSizedVLAType())
  return false;

return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6205}

6207inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6210}

6212inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6215}


6218inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6221}

6223inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6226}

6228inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6233}

6235inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6240}

6242inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6244}

6246inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6248}

6250inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6252}

6254inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6255, __PRETTY_FUNCTION__));
static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
              "Fast bits differ from CVR bits!");

// Fast path: we don't need to touch the slow qualifiers.
removeLocalFastQualifiers(Mask);
6261}

6263/// Return the address space of this type.
6264inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6266}

6268/// Return the gc attribute of this type.
6269inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6271}

6273inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6277}

6279inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6283}

6285inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6289}

6291inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const auto *PT = t.getAs<PointerType>()) {
  if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const auto *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
6299}

6301inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6303}

6305/// Determine whether this type is more
6306/// qualified than the Other type. For example, "const volatile int"
6307/// is more qualified than "const int", "volatile int", and
6308/// "int". However, it is not more qualified than "const volatile
6309/// int".
6310inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6314}

6316/// Determine whether this type is at last
6317/// as qualified as the Other type. For example, "const volatile
6318/// int" is at least as qualified as "const int", "volatile int",
6319/// "int", and "const volatile int".
6320inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
Qualifiers OtherQuals = other.getQualifiers();

// Ignore __unaligned qualifier if this type is a void.
if (getUnqualifiedType()->isVoidType())
  OtherQuals.removeUnaligned();

return getQualifiers().compatiblyIncludes(OtherQuals);
6328}

6330/// If Type is a reference type (e.g., const
6331/// int&), returns the type that the reference refers to ("const
6332/// int"). Otherwise, returns the type itself. This routine is used
6333/// throughout Sema to implement C++ 5p6:
6334///
6335///   If an expression initially has the type "reference to T" (8.3.2,
6336///   8.5.3), the type is adjusted to "T" prior to any further
6337///   analysis, the expression designates the object or function
6338///   denoted by the reference, and the expression is an lvalue.
6339inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6344}

6346inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6349}

6351/// Tests whether the type is categorized as a fundamental type.
6352///
6353/// \returns True for types specified in C++0x [basic.fundamental].
6354inline bool Type::isFundamentalType() const {
return isVoidType() ||
       isNullPtrType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
6360}

6362/// Tests whether the type is categorized as a compound type.
6363///
6364/// \returns True for types specified in C++0x [basic.compound].
6365inline bool Type::isCompoundType() const {
// C++0x [basic.compound]p1:
//   Compound types can be constructed in the following ways:
//    -- arrays of objects of a given type [...];
return isArrayType() ||
//    -- functions, which have parameters of given types [...];
       isFunctionType() ||
//    -- pointers to void or objects or functions [...];
       isPointerType() ||
//    -- references to objects or functions of a given type. [...]
       isReferenceType() ||
//    -- classes containing a sequence of objects of various types, [...];
       isRecordType() ||
//    -- unions, which are classes capable of containing objects of different
//               types at different times;
       isUnionType() ||
//    -- enumerations, which comprise a set of named constant values. [...];
       isEnumeralType() ||
//    -- pointers to non-static class members, [...].
       isMemberPointerType();
6385}

6387inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6389}

6391inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6393}

6395inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6397}

6399inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6401}

6403inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6405}

6407inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6409}

6411inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6413}

6415inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6420}

6422inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6427}

6429inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6431}

6433inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6438}

6440inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6445}

6447inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6449}

6451inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6453}

6455inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6457}

6459inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6461}

6463inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6465}

6467inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6469}

6471inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6473}

6475inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6477}

6479inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6481}

6483inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6485}

6487inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6489}

6491inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6493}

6495inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6497}

6499inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6501}

6503inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6506}

6508inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6510}

6512inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6516}

6518inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6522}

6524inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6528}

6530inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6534}

6536inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6540}

6542inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6544}

6546inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6548}

6550#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6554#include "clang/Basic/OpenCLImageTypes.def"

6556inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6558}

6560inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6562}

6564inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6566}

6568inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6570}

6572inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6574}

6576inline bool Type::isImageType() const {
6577#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6579#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6581}

6583inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6585}

6587#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6591#include "clang/Basic/OpenCLExtensionTypes.def"

6593inline bool Type::isOCLIntelSubgroupAVCType() const {
6594#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6597#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6599}

6601inline bool Type::isOCLExtOpaqueType() const {
6602#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6604#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6606}

6608inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6611}

6613inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6615}

6617inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>())
  if (BT->getKind() == (BuiltinType::Kind) K)
    return true;
return false;
6622}

6624inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6628}

6630inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6635}

6637inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)) ?
 static_cast<void> (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6638, __PRETTY_FUNCTION__));
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return (BT->getKind() == (BuiltinType::Kind) K);
return false;
6642}

6644inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6648}

6650inline bool Type::isVoidType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Void;
return false;
6654}

6656inline bool Type::isHalfType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Half;
// FIXME: Should we allow complex __fp16? Probably not.
return false;
6661}

6663inline bool Type::isFloat16Type() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float16;
return false;
6667}

6669inline bool Type::isFloat128Type() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float128;
return false;
6673}

6675inline bool Type::isNullPtrType() const {
if (const auto *BT = getAs<BuiltinType>())
  return BT->getKind() == BuiltinType::NullPtr;
return false;
6679}

6681bool IsEnumDeclComplete(EnumDecl *);
6682bool IsEnumDeclScoped(EnumDecl *);

6684inline bool Type::isIntegerType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
  // Incomplete enum types are not treated as integer types.
  // FIXME: In C++, enum types are never integer types.
  return IsEnumDeclComplete(ET->getDecl()) &&
    !IsEnumDeclScoped(ET->getDecl());
}
return false;
6695}

6697inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
6703}

6705inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
6707}

6709inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
6715}

6717inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
6719}

6721inline bool Type::isSignedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return ((BT->getKind() >= BuiltinType::ShortAccum &&
           BT->getKind() <= BuiltinType::LongAccum) ||
          (BT->getKind() >= BuiltinType::ShortFract &&
           BT->getKind() <= BuiltinType::LongFract) ||
          (BT->getKind() >= BuiltinType::SatShortAccum &&
           BT->getKind() <= BuiltinType::SatLongAccum) ||
          (BT->getKind() >= BuiltinType::SatShortFract &&
           BT->getKind() <= BuiltinType::SatLongFract));
}
return false;
6733}

6735inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
6737}

6739inline bool Type::isScalarType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() > BuiltinType::Void &&
         BT->getKind() <= BuiltinType::NullPtr;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  // Enums are scalar types, but only if they are defined.  Incomplete enums
  // are not treated as scalar types.
  return IsEnumDeclComplete(ET->getDecl());
return isa<PointerType>(CanonicalType) ||
       isa<BlockPointerType>(CanonicalType) ||
       isa<MemberPointerType>(CanonicalType) ||
       isa<ComplexType>(CanonicalType) ||
       isa<ObjCObjectPointerType>(CanonicalType);
6752}

6754inline bool Type::isIntegralOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;

// Check for a complete enum type; incomplete enum types are not properly an
// enumeration type in the sense required here.
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return false;
6765}

6767inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
6771}

6773inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
6776}

6778/// Determines whether this is a type for which one can define
6779/// an overloaded operator.
6780inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
6782}

6784/// Determines whether this type can decay to a pointer type.
6785inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
6787}

6789inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
6792}

6794inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
6796}

6798inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
6803}

6805inline const Type *Type::getPointeeOrArrayElementType() const {
const Type *type = this;
if (type->isAnyPointerType())
  return type->getPointeeType().getTypePtr();
else if (type->isArrayType())
  return type->getBaseElementTypeUnsafe();
return type;
6812}

6814/// Insertion operator for diagnostics. This allows sending Qualifiers into a
6815/// diagnostic with <<.
6816inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         Qualifiers Q) {
DB.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return DB;
6821}

6823/// Insertion operator for partial diagnostics. This allows sending Qualifiers
6824/// into a diagnostic with <<.
6825inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
6830}

6832/// Insertion operator for diagnostics.  This allows sending QualType's into a
6833/// diagnostic with <<.
6834inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         QualType T) {
DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return DB;
6839}

6841/// Insertion operator for partial diagnostics.  This allows sending QualType's
6842/// into a diagnostic with <<.
6843inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
6848}

6850// Helper class template that is used by Type::getAs to ensure that one does
6851// not try to look through a qualified type to get to an array type.
6852template <typename T>
6853using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

6857// Member-template getAs<specific type>'.
6858template <typename T> const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with getAs!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
6873}

6875template <typename T> const T *Type::getAsAdjusted() const {
static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// Strip off type adjustments that do not modify the underlying nature of the
// type.
const Type *Ty = this;
while (Ty) {
  if (const auto *A = dyn_cast<AttributedType>(Ty))
    Ty = A->getModifiedType().getTypePtr();
  else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
    Ty = E->desugar().getTypePtr();
  else if (const auto *P = dyn_cast<ParenType>(Ty))
    Ty = P->desugar().getTypePtr();
  else if (const auto *A = dyn_cast<AdjustedType>(Ty))
    Ty = A->desugar().getTypePtr();
  else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
    Ty = M->desugar().getTypePtr();
  else
    break;
}

// Just because the canonical type is correct does not mean we can use cast<>,
// since we may not have stripped off all the sugar down to the base type.
return dyn_cast<T>(Ty);
6907}

6909inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const auto *arr = dyn_cast<ArrayType>(this))
  return arr;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<ArrayType>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType());
6921}

6923template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const auto *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))((isa<T>(CanonicalType)) ? static_cast<void> (0) :
 __assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6928, __PRETTY_FUNCTION__));
return cast<T>(getUnqualifiedDesugaredType());
6930}

6932inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((isa<ArrayType>(CanonicalType)) ? static_cast<void>
 (0) : __assert_fail ("isa<ArrayType>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6933, __PRETTY_FUNCTION__));
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
6936}

6938DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
6941#ifndef NDEBUG
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((isa<PointerType>(Adjusted)) ? static_cast<void>
 (0) : __assert_fail ("isa<PointerType>(Adjusted)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6944, __PRETTY_FUNCTION__));
6945#endif
6946}

6948QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
6952}

6954// Get the decimal string representation of a fixed point type, represented
6955// as a scaled integer.
6956// TODO: At some point, we should change the arguments to instead just accept an
6957// APFixedPoint instead of APSInt and scale.
6958void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

6961} // namespace clang

6963#endif // LLVM_CLANG_AST_TYPE_H

←

/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h

1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16 
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23 
24namespace llvm {
25 
26template <typename T> struct PointerUnionTypeSelectorReturn {
27  using Return = T;
28};
29 
30/// Get a type based on whether two types are the same or not.
31///
32/// For:
33///
34/// \code
35///   using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
36/// \endcode
37///
38/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
39template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
40struct PointerUnionTypeSelector {
41  using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
42};
43 
44template <typename T, typename RET_EQ, typename RET_NE>
45struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
46  using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
47};
48 
49template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
50struct PointerUnionTypeSelectorReturn<
51    PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
52  using Return =
53      typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
54};
55 
56namespace pointer_union_detail {
57  /// Determine the number of bits required to store integers with values < n.
58  /// This is ceil(log2(n)).
59  constexpr int bitsRequired(unsigned n) {
60    return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
61  }
62 
63  template <typename... Ts> constexpr int lowBitsAvailable() {
64    return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
65  }
66 
67  /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
68  /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
69  /// list.
70  template <typename T, typename ...Us> struct TypeIndex;
71  template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
72    static constexpr int Index = 0;
73  };
74  template <typename T, typename U, typename... Us>
75  struct TypeIndex<T, U, Us...> {
76    static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
77  };
78  template <typename T> struct TypeIndex<T> {
79    static constexpr int Index = 0;
80  };
81 
82  /// Find the first type in a list of types.
83  template <typename T, typename...> struct GetFirstType {
84    using type = T;
85  };
86 
87  /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
88  /// for the template arguments.
89  template <typename ...PTs> class PointerUnionUIntTraits {
90  public:
91    static inline void *getAsVoidPointer(void *P) { return P; }
92    static inline void *getFromVoidPointer(void *P) { return P; }
93    static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
94  };
95 
96  /// Implement assigment in terms of construction.
97  template <typename Derived, typename T> struct AssignableFrom {
98    Derived &operator=(T t) {
99      return static_cast<Derived &>(*this) = Derived(t);
100    }
101  };
102 
103  template <typename Derived, typename ValTy, int I, typename ...Types>
104  class PointerUnionMembers;
105 
106  template <typename Derived, typename ValTy, int I>
107  class PointerUnionMembers<Derived, ValTy, I> {
108  protected:
109    ValTy Val;
110    PointerUnionMembers() = default;
111    PointerUnionMembers(ValTy Val) : Val(Val) {}
112 
113    friend struct PointerLikeTypeTraits<Derived>;
114  };
115 
116  template <typename Derived, typename ValTy, int I, typename Type,
117            typename ...Types>
118  class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
119      : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
120    using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
121  public:
122    using Base::Base;
123    PointerUnionMembers() = default;
124    PointerUnionMembers(Type V)
125        : Base(ValTy(const_cast<void *>(
126                         PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
127                     I)) {}
128 
129    using Base::operator=;
130    Derived &operator=(Type V) {
131      this->Val = ValTy(
132          const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
133          I);
134      return static_cast<Derived &>(*this);
135    };
136  };
137}
138 
139/// A discriminated union of two or more pointer types, with the discriminator
140/// in the low bit of the pointer.
141///
142/// This implementation is extremely efficient in space due to leveraging the
143/// low bits of the pointer, while exposing a natural and type-safe API.
144///
145/// Common use patterns would be something like this:
146///    PointerUnion<int*, float*> P;
147///    P = (int*)0;
148///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
149///    X = P.get<int*>();     // ok.
150///    Y = P.get<float*>();   // runtime assertion failure.
151///    Z = P.get<double*>();  // compile time failure.
152///    P = (float*)0;
153///    Y = P.get<float*>();   // ok.
154///    X = P.get<int*>();     // runtime assertion failure.
155template <typename... PTs>
156class PointerUnion
157    : public pointer_union_detail::PointerUnionMembers<
158          PointerUnion<PTs...>,
159          PointerIntPair<
160              void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
161              pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
162          0, PTs...> {
163  // The first type is special because we want to directly cast a pointer to a
164  // default-initialized union to a pointer to the first type. But we don't
165  // want PointerUnion to be a 'template <typename First, typename ...Rest>'
166  // because it's much more convenient to have a name for the whole pack. So
167  // split off the first type here.
168  using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
169  using Base = typename PointerUnion::PointerUnionMembers;
170 
171public:
172  PointerUnion() = default;
173 
174  PointerUnion(std::nullptr_t) : PointerUnion() {}
175  using Base::Base;
176 
177  /// Test if the pointer held in the union is null, regardless of
178  /// which type it is.
179  bool isNull() const { return !this->Val.getPointer(); }
10
←
Assuming the condition is false→
11
←
Returning zero, which participates in a condition later→
180 
181  explicit operator bool() const { return !isNull(); }
182 
183  /// Test if the Union currently holds the type matching T.
184  template <typename T> int is() const {
185    constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
186    static_assert(Index < sizeof...(PTs),
187                  "PointerUnion::is<T> given type not in the union");
188    return this->Val.getInt() == Index;
189  }
190 
191  /// Returns the value of the specified pointer type.
192  ///
193  /// If the specified pointer type is incorrect, assert.
194  template <typename T> T get() const {
195    assert(is<T>() && "Invalid accessor called")((is<T>() && "Invalid accessor called") ? static_cast
<void> (0) : __assert_fail ("is<T>() && \"Invalid accessor called\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h"
, 195, __PRETTY_FUNCTION__));
196    return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
197  }
198 
199  /// Returns the current pointer if it is of the specified pointer type,
200  /// otherwises returns null.
201  template <typename T> T dyn_cast() const {
202    if (is<T>())
203      return get<T>();
204    return T();
205  }
206 
207  /// If the union is set to the first pointer type get an address pointing to
208  /// it.
209  First const *getAddrOfPtr1() const {
210    return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
211  }
212 
213  /// If the union is set to the first pointer type get an address pointing to
214  /// it.
215  First *getAddrOfPtr1() {
216    assert(is<First>() && "Val is not the first pointer")((is<First>() && "Val is not the first pointer"
) ? static_cast<void> (0) : __assert_fail ("is<First>() && \"Val is not the first pointer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h"
, 216, __PRETTY_FUNCTION__));
217    assert(((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
218        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
219            this->Val.getPointer() &&((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
220        "Can't get the address because PointerLikeTypeTraits changes the ptr")((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__));
221    return const_cast<First *>(
222        reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
223  }
224 
225  /// Assignment from nullptr which just clears the union.
226  const PointerUnion &operator=(std::nullptr_t) {
227    this->Val.initWithPointer(nullptr);
228    return *this;
229  }
230 
231  /// Assignment from elements of the union.
232  using Base::operator=;
233 
234  void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
235  static inline PointerUnion getFromOpaqueValue(void *VP) {
236    PointerUnion V;
237    V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
238    return V;
239  }
240};
241 
242template <typename ...PTs>
243bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
244  return lhs.getOpaqueValue() == rhs.getOpaqueValue();
245}
246 
247template <typename ...PTs>
248bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
249  return lhs.getOpaqueValue() != rhs.getOpaqueValue();
250}
251 
252template <typename ...PTs>
253bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
254  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
255}
256 
257// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
258// # low bits available = min(PT1bits,PT2bits)-1.
259template <typename ...PTs>
260struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
261  static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
262    return P.getOpaqueValue();
263  }
264 
265  static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
266    return PointerUnion<PTs...>::getFromOpaqueValue(P);
267  }
268 
269  // The number of bits available are the min of the pointer types minus the
270  // bits needed for the discriminator.
271  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
272      PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
273};
274 
275/// A pointer union of three pointer types. See documentation for PointerUnion
276/// for usage.
277template <typename PT1, typename PT2, typename PT3>
278using PointerUnion3 = PointerUnion<PT1, PT2, PT3>;
279 
280/// A pointer union of four pointer types. See documentation for PointerUnion
281/// for usage.
282template <typename PT1, typename PT2, typename PT3, typename PT4>
283using PointerUnion4 = PointerUnion<PT1, PT2, PT3, PT4>;
284 
285// Teach DenseMap how to use PointerUnions as keys.
286template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
287  using Union = PointerUnion<PTs...>;
288  using FirstInfo =
289      DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
290 
291  static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
292 
293  static inline Union getTombstoneKey() {
294    return Union(FirstInfo::getTombstoneKey());
295  }
296 
297  static unsigned getHashValue(const Union &UnionVal) {
298    intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
299    return DenseMapInfo<intptr_t>::getHashValue(key);
300  }
301 
302  static bool isEqual(const Union &LHS, const Union &RHS) {
303    return LHS == RHS;
304  }
305};
306 
307} // end namespace llvm
308 
309#endif // LLVM_ADT_POINTERUNION_H