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

Bug Summary

File:	build/source/clang/lib/Sema/SemaExpr.cpp
Warning:	line 4855, column 7 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

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

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

→

1//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
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 implements semantic analysis for expressions.
10//
11//===----------------------------------------------------------------------===//

13#include "TreeTransform.h"
14#include "UsedDeclVisitor.h"
15#include "clang/AST/ASTConsumer.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTLambda.h"
18#include "clang/AST/ASTMutationListener.h"
19#include "clang/AST/CXXInheritance.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/EvaluatedExprVisitor.h"
23#include "clang/AST/Expr.h"
24#include "clang/AST/ExprCXX.h"
25#include "clang/AST/ExprObjC.h"
26#include "clang/AST/ExprOpenMP.h"
27#include "clang/AST/OperationKinds.h"
28#include "clang/AST/ParentMapContext.h"
29#include "clang/AST/RecursiveASTVisitor.h"
30#include "clang/AST/Type.h"
31#include "clang/AST/TypeLoc.h"
32#include "clang/Basic/Builtins.h"
33#include "clang/Basic/DiagnosticSema.h"
34#include "clang/Basic/PartialDiagnostic.h"
35#include "clang/Basic/SourceManager.h"
36#include "clang/Basic/Specifiers.h"
37#include "clang/Basic/TargetInfo.h"
38#include "clang/Lex/LiteralSupport.h"
39#include "clang/Lex/Preprocessor.h"
40#include "clang/Sema/AnalysisBasedWarnings.h"
41#include "clang/Sema/DeclSpec.h"
42#include "clang/Sema/DelayedDiagnostic.h"
43#include "clang/Sema/Designator.h"
44#include "clang/Sema/EnterExpressionEvaluationContext.h"
45#include "clang/Sema/Initialization.h"
46#include "clang/Sema/Lookup.h"
47#include "clang/Sema/Overload.h"
48#include "clang/Sema/ParsedTemplate.h"
49#include "clang/Sema/Scope.h"
50#include "clang/Sema/ScopeInfo.h"
51#include "clang/Sema/SemaFixItUtils.h"
52#include "clang/Sema/SemaInternal.h"
53#include "clang/Sema/Template.h"
54#include "llvm/ADT/STLExtras.h"
55#include "llvm/ADT/StringExtras.h"
56#include "llvm/Support/Casting.h"
57#include "llvm/Support/ConvertUTF.h"
58#include "llvm/Support/SaveAndRestore.h"
59#include "llvm/Support/TypeSize.h"
60#include <optional>

62using namespace clang;
63using namespace sema;

65/// Determine whether the use of this declaration is valid, without
66/// emitting diagnostics.
67bool Sema::CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid) {
// See if this is an auto-typed variable whose initializer we are parsing.
if (ParsingInitForAutoVars.count(D))
  return false;

// See if this is a deleted function.
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  if (FD->isDeleted())
    return false;

  // If the function has a deduced return type, and we can't deduce it,
  // then we can't use it either.
  if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
      DeduceReturnType(FD, SourceLocation(), /*Diagnose*/ false))
    return false;

  // See if this is an aligned allocation/deallocation function that is
  // unavailable.
  if (TreatUnavailableAsInvalid &&
      isUnavailableAlignedAllocationFunction(*FD))
    return false;
}

// See if this function is unavailable.
if (TreatUnavailableAsInvalid && D->getAvailability() == AR_Unavailable &&
    cast<Decl>(CurContext)->getAvailability() != AR_Unavailable)
  return false;

if (isa<UnresolvedUsingIfExistsDecl>(D))
  return false;

return true;
99}

101static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc) {
// Warn if this is used but marked unused.
if (const auto *A = D->getAttr<UnusedAttr>()) {
  // [[maybe_unused]] should not diagnose uses, but __attribute__((unused))
  // should diagnose them.
  if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
      A->getSemanticSpelling() != UnusedAttr::C2x_maybe_unused) {
    const Decl *DC = cast_or_null<Decl>(S.getCurObjCLexicalContext());
    if (DC && !DC->hasAttr<UnusedAttr>())
      S.Diag(Loc, diag::warn_used_but_marked_unused) << D;
  }
}
113}

115/// Emit a note explaining that this function is deleted.
116void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
assert(Decl && Decl->isDeleted())(static_cast <bool> (Decl && Decl->isDeleted
()) ? void (0) : __assert_fail ("Decl && Decl->isDeleted()"
, "clang/lib/Sema/SemaExpr.cpp", 117, __extension__ __PRETTY_FUNCTION__
));

if (Decl->isDefaulted()) {
  // If the method was explicitly defaulted, point at that declaration.
  if (!Decl->isImplicit())
    Diag(Decl->getLocation(), diag::note_implicitly_deleted);

  // Try to diagnose why this special member function was implicitly
  // deleted. This might fail, if that reason no longer applies.
  DiagnoseDeletedDefaultedFunction(Decl);
  return;
}

auto *Ctor = dyn_cast<CXXConstructorDecl>(Decl);
if (Ctor && Ctor->isInheritingConstructor())
  return NoteDeletedInheritingConstructor(Ctor);

Diag(Decl->getLocation(), diag::note_availability_specified_here)
  << Decl << 1;
136}

138/// Determine whether a FunctionDecl was ever declared with an
139/// explicit storage class.
140static bool hasAnyExplicitStorageClass(const FunctionDecl *D) {
for (auto *I : D->redecls()) {
  if (I->getStorageClass() != SC_None)
    return true;
}
return false;
146}

148/// Check whether we're in an extern inline function and referring to a
149/// variable or function with internal linkage (C11 6.7.4p3).
150///
151/// This is only a warning because we used to silently accept this code, but
152/// in many cases it will not behave correctly. This is not enabled in C++ mode
153/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)
154/// and so while there may still be user mistakes, most of the time we can't
155/// prove that there are errors.
156static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S,
                                                    const NamedDecl *D,
                                                    SourceLocation Loc) {
// This is disabled under C++; there are too many ways for this to fire in
// contexts where the warning is a false positive, or where it is technically
// correct but benign.
if (S.getLangOpts().CPlusPlus)
  return;

// Check if this is an inlined function or method.
FunctionDecl *Current = S.getCurFunctionDecl();
if (!Current)
  return;
if (!Current->isInlined())
  return;
if (!Current->isExternallyVisible())
  return;

// Check if the decl has internal linkage.
if (D->getFormalLinkage() != InternalLinkage)
  return;

// Downgrade from ExtWarn to Extension if
//  (1) the supposedly external inline function is in the main file,
//      and probably won't be included anywhere else.
//  (2) the thing we're referencing is a pure function.
//  (3) the thing we're referencing is another inline function.
// This last can give us false negatives, but it's better than warning on
// wrappers for simple C library functions.
const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D);
bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc);
if (!DowngradeWarning && UsedFn)
  DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>();

S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
                             : diag::ext_internal_in_extern_inline)
  << /*IsVar=*/!UsedFn << D;

S.MaybeSuggestAddingStaticToDecl(Current);

S.Diag(D->getCanonicalDecl()->getLocation(), diag::note_entity_declared_at)
    << D;
198}

200void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) {
const FunctionDecl *First = Cur->getFirstDecl();

// Suggest "static" on the function, if possible.
if (!hasAnyExplicitStorageClass(First)) {
  SourceLocation DeclBegin = First->getSourceRange().getBegin();
  Diag(DeclBegin, diag::note_convert_inline_to_static)
    << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
}
209}

211/// Determine whether the use of this declaration is valid, and
212/// emit any corresponding diagnostics.
213///
214/// This routine diagnoses various problems with referencing
215/// declarations that can occur when using a declaration. For example,
216/// it might warn if a deprecated or unavailable declaration is being
217/// used, or produce an error (and return true) if a C++0x deleted
218/// function is being used.
219///
220/// \returns true if there was an error (this declaration cannot be
221/// referenced), false otherwise.
222///
223bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
                           const ObjCInterfaceDecl *UnknownObjCClass,
                           bool ObjCPropertyAccess,
                           bool AvoidPartialAvailabilityChecks,
                           ObjCInterfaceDecl *ClassReceiver,
                           bool SkipTrailingRequiresClause) {
SourceLocation Loc = Locs.front();
if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {
  // If there were any diagnostics suppressed by template argument deduction,
  // emit them now.
  auto Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
  if (Pos != SuppressedDiagnostics.end()) {
    for (const PartialDiagnosticAt &Suppressed : Pos->second)
      Diag(Suppressed.first, Suppressed.second);

    // Clear out the list of suppressed diagnostics, so that we don't emit
    // them again for this specialization. However, we don't obsolete this
    // entry from the table, because we want to avoid ever emitting these
    // diagnostics again.
    Pos->second.clear();
  }

  // C++ [basic.start.main]p3:
  //   The function 'main' shall not be used within a program.
  if (cast<FunctionDecl>(D)->isMain())
    Diag(Loc, diag::ext_main_used);

  diagnoseUnavailableAlignedAllocation(*cast<FunctionDecl>(D), Loc);
}

// See if this is an auto-typed variable whose initializer we are parsing.
if (ParsingInitForAutoVars.count(D)) {
  if (isa<BindingDecl>(D)) {
    Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
      << D->getDeclName();
  } else {
    Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
      << D->getDeclName() << cast<VarDecl>(D)->getType();
  }
  return true;
}

if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  // See if this is a deleted function.
  if (FD->isDeleted()) {
    auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
    if (Ctor && Ctor->isInheritingConstructor())
      Diag(Loc, diag::err_deleted_inherited_ctor_use)
          << Ctor->getParent()
          << Ctor->getInheritedConstructor().getConstructor()->getParent();
    else
      Diag(Loc, diag::err_deleted_function_use);
    NoteDeletedFunction(FD);
    return true;
  }

  // [expr.prim.id]p4
  //   A program that refers explicitly or implicitly to a function with a
  //   trailing requires-clause whose constraint-expression is not satisfied,
  //   other than to declare it, is ill-formed. [...]
  //
  // See if this is a function with constraints that need to be satisfied.
  // Check this before deducing the return type, as it might instantiate the
  // definition.
  if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {
    ConstraintSatisfaction Satisfaction;
    if (CheckFunctionConstraints(FD, Satisfaction, Loc,
                                 /*ForOverloadResolution*/ true))
      // A diagnostic will have already been generated (non-constant
      // constraint expression, for example)
      return true;
    if (!Satisfaction.IsSatisfied) {
      Diag(Loc,
           diag::err_reference_to_function_with_unsatisfied_constraints)
          << D;
      DiagnoseUnsatisfiedConstraint(Satisfaction);
      return true;
    }
  }

  // If the function has a deduced return type, and we can't deduce it,
  // then we can't use it either.
  if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
      DeduceReturnType(FD, Loc))
    return true;

  if (getLangOpts().CUDA && !CheckCUDACall(Loc, FD))
    return true;

}

if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {
  // Lambdas are only default-constructible or assignable in C++2a onwards.
  if (MD->getParent()->isLambda() &&
      ((isa<CXXConstructorDecl>(MD) &&
        cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
       MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
    Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
      << !isa<CXXConstructorDecl>(MD);
  }
}

auto getReferencedObjCProp = [](const NamedDecl *D) ->
                                    const ObjCPropertyDecl * {
  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
    return MD->findPropertyDecl();
  return nullptr;
};
if (const ObjCPropertyDecl *ObjCPDecl = getReferencedObjCProp(D)) {
  if (diagnoseArgIndependentDiagnoseIfAttrs(ObjCPDecl, Loc))
    return true;
} else if (diagnoseArgIndependentDiagnoseIfAttrs(D, Loc)) {
    return true;
}

// [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
// Only the variables omp_in and omp_out are allowed in the combiner.
// Only the variables omp_priv and omp_orig are allowed in the
// initializer-clause.
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(CurContext);
if (LangOpts.OpenMP && DRD && !CurContext->containsDecl(D) &&
    isa<VarDecl>(D)) {
  Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)
      << getCurFunction()->HasOMPDeclareReductionCombiner;
  Diag(D->getLocation(), diag::note_entity_declared_at) << D;
  return true;
}

// [OpenMP 5.0], 2.19.7.3. declare mapper Directive, Restrictions
//  List-items in map clauses on this construct may only refer to the declared
//  variable var and entities that could be referenced by a procedure defined
//  at the same location.
// [OpenMP 5.2] Also allow iterator declared variables.
if (LangOpts.OpenMP && isa<VarDecl>(D) &&
    !isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(D))) {
  Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
      << getOpenMPDeclareMapperVarName();
  Diag(D->getLocation(), diag::note_entity_declared_at) << D;
  return true;
}

if (const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {
  Diag(Loc, diag::err_use_of_empty_using_if_exists);
  Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
  return true;
}

DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,
                           AvoidPartialAvailabilityChecks, ClassReceiver);

DiagnoseUnusedOfDecl(*this, D, Loc);

diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);

if (auto *VD = dyn_cast<ValueDecl>(D))
  checkTypeSupport(VD->getType(), Loc, VD);

if (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)) {
  if (!Context.getTargetInfo().isTLSSupported())
    if (const auto *VD = dyn_cast<VarDecl>(D))
      if (VD->getTLSKind() != VarDecl::TLS_None)
        targetDiag(*Locs.begin(), diag::err_thread_unsupported);
}

if (isa<ParmVarDecl>(D) && isa<RequiresExprBodyDecl>(D->getDeclContext()) &&
    !isUnevaluatedContext()) {
  // C++ [expr.prim.req.nested] p3
  //   A local parameter shall only appear as an unevaluated operand
  //   (Clause 8) within the constraint-expression.
  Diag(Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context)
      << D;
  Diag(D->getLocation(), diag::note_entity_declared_at) << D;
  return true;
}

return false;
399}

401/// DiagnoseSentinelCalls - This routine checks whether a call or
402/// message-send is to a declaration with the sentinel attribute, and
403/// if so, it checks that the requirements of the sentinel are
404/// satisfied.
405void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
                               ArrayRef<Expr *> Args) {
const SentinelAttr *attr = D->getAttr<SentinelAttr>();
if (!attr)
  return;

// The number of formal parameters of the declaration.
unsigned numFormalParams;

// The kind of declaration.  This is also an index into a %select in
// the diagnostic.
enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType;

if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
  numFormalParams = MD->param_size();
  calleeType = CT_Method;
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  numFormalParams = FD->param_size();
  calleeType = CT_Function;
} else if (isa<VarDecl>(D)) {
  QualType type = cast<ValueDecl>(D)->getType();
  const FunctionType *fn = nullptr;
  if (const PointerType *ptr = type->getAs<PointerType>()) {
    fn = ptr->getPointeeType()->getAs<FunctionType>();
    if (!fn) return;
    calleeType = CT_Function;
  } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) {
    fn = ptr->getPointeeType()->castAs<FunctionType>();
    calleeType = CT_Block;
  } else {
    return;
  }

  if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) {
    numFormalParams = proto->getNumParams();
  } else {
    numFormalParams = 0;
  }
} else {
  return;
}

// "nullPos" is the number of formal parameters at the end which
// effectively count as part of the variadic arguments.  This is
// useful if you would prefer to not have *any* formal parameters,
// but the language forces you to have at least one.
unsigned nullPos = attr->getNullPos();
assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel")(static_cast <bool> ((nullPos == 0 || nullPos == 1) &&
 "invalid null position on sentinel") ? void (0) : __assert_fail
 ("(nullPos == 0 || nullPos == 1) && \"invalid null position on sentinel\""
, "clang/lib/Sema/SemaExpr.cpp", 452, __extension__ __PRETTY_FUNCTION__
));
numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos);

// The number of arguments which should follow the sentinel.
unsigned numArgsAfterSentinel = attr->getSentinel();

// If there aren't enough arguments for all the formal parameters,
// the sentinel, and the args after the sentinel, complain.
if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) {
  Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
  Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
  return;
}

// Otherwise, find the sentinel expression.
Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
if (!sentinelExpr) return;
if (sentinelExpr->isValueDependent()) return;
if (Context.isSentinelNullExpr(sentinelExpr)) return;

// Pick a reasonable string to insert.  Optimistically use 'nil', 'nullptr',
// or 'NULL' if those are actually defined in the context.  Only use
// 'nil' for ObjC methods, where it's much more likely that the
// variadic arguments form a list of object pointers.
SourceLocation MissingNilLoc = getLocForEndOfToken(sentinelExpr->getEndLoc());
std::string NullValue;
if (calleeType == CT_Method && PP.isMacroDefined("nil"))
  NullValue = "nil";
else if (getLangOpts().CPlusPlus11)
  NullValue = "nullptr";
else if (PP.isMacroDefined("NULL"))
  NullValue = "NULL";
else
  NullValue = "(void*) 0";

if (MissingNilLoc.isInvalid())
  Diag(Loc, diag::warn_missing_sentinel) << int(calleeType);
else
  Diag(MissingNilLoc, diag::warn_missing_sentinel)
    << int(calleeType)
    << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue);
Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
494}

496SourceRange Sema::getExprRange(Expr *E) const {
return E ? E->getSourceRange() : SourceRange();
498}

500//===----------------------------------------------------------------------===//
501//  Standard Promotions and Conversions
502//===----------------------------------------------------------------------===//

504/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
505ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {
// Handle any placeholder expressions which made it here.
if (E->hasPlaceholderType()) {
  ExprResult result = CheckPlaceholderExpr(E);
  if (result.isInvalid()) return ExprError();
  E = result.get();
}

QualType Ty = E->getType();
assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type")(static_cast <bool> (!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"
) ? void (0) : __assert_fail ("!Ty.isNull() && \"DefaultFunctionArrayConversion - missing type\""
, "clang/lib/Sema/SemaExpr.cpp", 514, __extension__ __PRETTY_FUNCTION__
));

if (Ty->isFunctionType()) {
  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))
    if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
      if (!checkAddressOfFunctionIsAvailable(FD, Diagnose, E->getExprLoc()))
        return ExprError();

  E = ImpCastExprToType(E, Context.getPointerType(Ty),
                        CK_FunctionToPointerDecay).get();
} else if (Ty->isArrayType()) {
  // In C90 mode, arrays only promote to pointers if the array expression is
  // an lvalue.  The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
  // type 'array of type' is converted to an expression that has type 'pointer
  // to type'...".  In C99 this was changed to: C99 6.3.2.1p3: "an expression
  // that has type 'array of type' ...".  The relevant change is "an lvalue"
  // (C90) to "an expression" (C99).
  //
  // C++ 4.2p1:
  // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
  // T" can be converted to an rvalue of type "pointer to T".
  //
  if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) {
    ExprResult Res = ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
                                       CK_ArrayToPointerDecay);
    if (Res.isInvalid())
      return ExprError();
    E = Res.get();
  }
}
return E;
545}

547static void CheckForNullPointerDereference(Sema &S, Expr *E) {
// Check to see if we are dereferencing a null pointer.  If so,
// and if not volatile-qualified, this is undefined behavior that the
// optimizer will delete, so warn about it.  People sometimes try to use this
// to get a deterministic trap and are surprised by clang's behavior.  This
// only handles the pattern "*null", which is a very syntactic check.
const auto *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts());
if (UO && UO->getOpcode() == UO_Deref &&
    UO->getSubExpr()->getType()->isPointerType()) {
  const LangAS AS =
      UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();
  if ((!isTargetAddressSpace(AS) ||
       (isTargetAddressSpace(AS) && toTargetAddressSpace(AS) == 0)) &&
      UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(
          S.Context, Expr::NPC_ValueDependentIsNotNull) &&
      !UO->getType().isVolatileQualified()) {
    S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
                          S.PDiag(diag::warn_indirection_through_null)
                              << UO->getSubExpr()->getSourceRange());
    S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
                          S.PDiag(diag::note_indirection_through_null));
  }
}
570}

572static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
                                  SourceLocation AssignLoc,
                                  const Expr* RHS) {
const ObjCIvarDecl *IV = OIRE->getDecl();
if (!IV)
  return;

DeclarationName MemberName = IV->getDeclName();
IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
if (!Member || !Member->isStr("isa"))
  return;

const Expr *Base = OIRE->getBase();
QualType BaseType = Base->getType();
if (OIRE->isArrow())
  BaseType = BaseType->getPointeeType();
if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())
  if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {
    ObjCInterfaceDecl *ClassDeclared = nullptr;
    ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
    if (!ClassDeclared->getSuperClass()
        && (*ClassDeclared->ivar_begin()) == IV) {
      if (RHS) {
        NamedDecl *ObjectSetClass =
          S.LookupSingleName(S.TUScope,
                             &S.Context.Idents.get("object_setClass"),
                             SourceLocation(), S.LookupOrdinaryName);
        if (ObjectSetClass) {
          SourceLocation RHSLocEnd = S.getLocForEndOfToken(RHS->getEndLoc());
          S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign)
              << FixItHint::CreateInsertion(OIRE->getBeginLoc(),
                                            "object_setClass(")
              << FixItHint::CreateReplacement(
                     SourceRange(OIRE->getOpLoc(), AssignLoc), ",")
              << FixItHint::CreateInsertion(RHSLocEnd, ")");
        }
        else
          S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);
      } else {
        NamedDecl *ObjectGetClass =
          S.LookupSingleName(S.TUScope,
                             &S.Context.Idents.get("object_getClass"),
                             SourceLocation(), S.LookupOrdinaryName);
        if (ObjectGetClass)
          S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use)
              << FixItHint::CreateInsertion(OIRE->getBeginLoc(),
                                            "object_getClass(")
              << FixItHint::CreateReplacement(
                     SourceRange(OIRE->getOpLoc(), OIRE->getEndLoc()), ")");
        else
          S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use);
      }
      S.Diag(IV->getLocation(), diag::note_ivar_decl);
    }
  }
627}

629ExprResult Sema::DefaultLvalueConversion(Expr *E) {
// Handle any placeholder expressions which made it here.
if (E->hasPlaceholderType()) {
  ExprResult result = CheckPlaceholderExpr(E);
  if (result.isInvalid()) return ExprError();
  E = result.get();
}

// C++ [conv.lval]p1:
//   A glvalue of a non-function, non-array type T can be
//   converted to a prvalue.
if (!E->isGLValue()) return E;

QualType T = E->getType();
assert(!T.isNull() && "r-value conversion on typeless expression?")(static_cast <bool> (!T.isNull() && "r-value conversion on typeless expression?"
) ? void (0) : __assert_fail ("!T.isNull() && \"r-value conversion on typeless expression?\""
, "clang/lib/Sema/SemaExpr.cpp", 643, __extension__ __PRETTY_FUNCTION__
));

// lvalue-to-rvalue conversion cannot be applied to function or array types.
if (T->isFunctionType() || T->isArrayType())
  return E;

// We don't want to throw lvalue-to-rvalue casts on top of
// expressions of certain types in C++.
if (getLangOpts().CPlusPlus &&
    (E->getType() == Context.OverloadTy ||
     T->isDependentType() ||
     T->isRecordType()))
  return E;

// The C standard is actually really unclear on this point, and
// DR106 tells us what the result should be but not why.  It's
// generally best to say that void types just doesn't undergo
// lvalue-to-rvalue at all.  Note that expressions of unqualified
// 'void' type are never l-values, but qualified void can be.
if (T->isVoidType())
  return E;

// OpenCL usually rejects direct accesses to values of 'half' type.
if (getLangOpts().OpenCL &&
    !getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&
    T->isHalfType()) {
  Diag(E->getExprLoc(), diag::err_opencl_half_load_store)
    << 0 << T;
  return ExprError();
}

CheckForNullPointerDereference(*this, E);
if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {
  NamedDecl *ObjectGetClass = LookupSingleName(TUScope,
                                   &Context.Idents.get("object_getClass"),
                                   SourceLocation(), LookupOrdinaryName);
  if (ObjectGetClass)
    Diag(E->getExprLoc(), diag::warn_objc_isa_use)
        << FixItHint::CreateInsertion(OISA->getBeginLoc(), "object_getClass(")
        << FixItHint::CreateReplacement(
               SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");
  else
    Diag(E->getExprLoc(), diag::warn_objc_isa_use);
}
else if (const ObjCIvarRefExpr *OIRE =
          dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
  DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);

// C++ [conv.lval]p1:
//   [...] If T is a non-class type, the type of the prvalue is the
//   cv-unqualified version of T. Otherwise, the type of the
//   rvalue is T.
//
// C99 6.3.2.1p2:
//   If the lvalue has qualified type, the value has the unqualified
//   version of the type of the lvalue; otherwise, the value has the
//   type of the lvalue.
if (T.hasQualifiers())
  T = T.getUnqualifiedType();

// Under the MS ABI, lock down the inheritance model now.
if (T->isMemberPointerType() &&
    Context.getTargetInfo().getCXXABI().isMicrosoft())
  (void)isCompleteType(E->getExprLoc(), T);

ExprResult Res = CheckLValueToRValueConversionOperand(E);
if (Res.isInvalid())
  return Res;
E = Res.get();

// Loading a __weak object implicitly retains the value, so we need a cleanup to
// balance that.
if (E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
  Cleanup.setExprNeedsCleanups(true);

if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
  Cleanup.setExprNeedsCleanups(true);

// C++ [conv.lval]p3:
//   If T is cv std::nullptr_t, the result is a null pointer constant.
CastKind CK = T->isNullPtrType() ? CK_NullToPointer : CK_LValueToRValue;
Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_PRValue,
                               CurFPFeatureOverrides());

// C11 6.3.2.1p2:
//   ... if the lvalue has atomic type, the value has the non-atomic version
//   of the type of the lvalue ...
if (const AtomicType *Atomic = T->getAs<AtomicType>()) {
  T = Atomic->getValueType().getUnqualifiedType();
  Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(),
                                 nullptr, VK_PRValue, FPOptionsOverride());
}

return Res;
737}

739ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose) {
ExprResult Res = DefaultFunctionArrayConversion(E, Diagnose);
if (Res.isInvalid())
  return ExprError();
Res = DefaultLvalueConversion(Res.get());
if (Res.isInvalid())
  return ExprError();
return Res;
747}

749/// CallExprUnaryConversions - a special case of an unary conversion
750/// performed on a function designator of a call expression.
751ExprResult Sema::CallExprUnaryConversions(Expr *E) {
QualType Ty = E->getType();
ExprResult Res = E;
// Only do implicit cast for a function type, but not for a pointer
// to function type.
if (Ty->isFunctionType()) {
  Res = ImpCastExprToType(E, Context.getPointerType(Ty),
                          CK_FunctionToPointerDecay);
  if (Res.isInvalid())
    return ExprError();
}
Res = DefaultLvalueConversion(Res.get());
if (Res.isInvalid())
  return ExprError();
return Res.get();
766}

768/// UsualUnaryConversions - Performs various conversions that are common to most
769/// operators (C99 6.3). The conversions of array and function types are
770/// sometimes suppressed. For example, the array->pointer conversion doesn't
771/// apply if the array is an argument to the sizeof or address (&) operators.
772/// In these instances, this routine should *not* be called.
773ExprResult Sema::UsualUnaryConversions(Expr *E) {
// First, convert to an r-value.
ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
if (Res.isInvalid())
  return ExprError();
E = Res.get();

QualType Ty = E->getType();
assert(!Ty.isNull() && "UsualUnaryConversions - missing type")(static_cast <bool> (!Ty.isNull() && "UsualUnaryConversions - missing type"
) ? void (0) : __assert_fail ("!Ty.isNull() && \"UsualUnaryConversions - missing type\""
, "clang/lib/Sema/SemaExpr.cpp", 781, __extension__ __PRETTY_FUNCTION__
));

LangOptions::FPEvalMethodKind EvalMethod = CurFPFeatures.getFPEvalMethod();
if (EvalMethod != LangOptions::FEM_Source && Ty->isFloatingType() &&
    (getLangOpts().getFPEvalMethod() !=
         LangOptions::FPEvalMethodKind::FEM_UnsetOnCommandLine ||
     PP.getLastFPEvalPragmaLocation().isValid())) {
  switch (EvalMethod) {
  default:
    llvm_unreachable("Unrecognized float evaluation method")::llvm::llvm_unreachable_internal("Unrecognized float evaluation method"
, "clang/lib/Sema/SemaExpr.cpp", 790);
    break;
  case LangOptions::FEM_UnsetOnCommandLine:
    llvm_unreachable("Float evaluation method should be set by now")::llvm::llvm_unreachable_internal("Float evaluation method should be set by now"
, "clang/lib/Sema/SemaExpr.cpp", 793);
    break;
  case LangOptions::FEM_Double:
    if (Context.getFloatingTypeOrder(Context.DoubleTy, Ty) > 0)
      // Widen the expression to double.
      return Ty->isComplexType()
                 ? ImpCastExprToType(E,
                                     Context.getComplexType(Context.DoubleTy),
                                     CK_FloatingComplexCast)
                 : ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast);
    break;
  case LangOptions::FEM_Extended:
    if (Context.getFloatingTypeOrder(Context.LongDoubleTy, Ty) > 0)
      // Widen the expression to long double.
      return Ty->isComplexType()
                 ? ImpCastExprToType(
                       E, Context.getComplexType(Context.LongDoubleTy),
                       CK_FloatingComplexCast)
                 : ImpCastExprToType(E, Context.LongDoubleTy,
                                     CK_FloatingCast);
    break;
  }
}

// Half FP have to be promoted to float unless it is natively supported
if (Ty->isHalfType() && !getLangOpts().NativeHalfType)
  return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast);

// Try to perform integral promotions if the object has a theoretically
// promotable type.
if (Ty->isIntegralOrUnscopedEnumerationType()) {
  // C99 6.3.1.1p2:
  //
  //   The following may be used in an expression wherever an int or
  //   unsigned int may be used:
  //     - an object or expression with an integer type whose integer
  //       conversion rank is less than or equal to the rank of int
  //       and unsigned int.
  //     - A bit-field of type _Bool, int, signed int, or unsigned int.
  //
  //   If an int can represent all values of the original type, the
  //   value is converted to an int; otherwise, it is converted to an
  //   unsigned int. These are called the integer promotions. All
  //   other types are unchanged by the integer promotions.

  QualType PTy = Context.isPromotableBitField(E);
  if (!PTy.isNull()) {
    E = ImpCastExprToType(E, PTy, CK_IntegralCast).get();
    return E;
  }
  if (Context.isPromotableIntegerType(Ty)) {
    QualType PT = Context.getPromotedIntegerType(Ty);
    E = ImpCastExprToType(E, PT, CK_IntegralCast).get();
    return E;
  }
}
return E;
850}

852/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
853/// do not have a prototype. Arguments that have type float or __fp16
854/// are promoted to double. All other argument types are converted by
855/// UsualUnaryConversions().
856ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
QualType Ty = E->getType();
assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type")(static_cast <bool> (!Ty.isNull() && "DefaultArgumentPromotion - missing type"
) ? void (0) : __assert_fail ("!Ty.isNull() && \"DefaultArgumentPromotion - missing type\""
, "clang/lib/Sema/SemaExpr.cpp", 858, __extension__ __PRETTY_FUNCTION__
));

ExprResult Res = UsualUnaryConversions(E);
if (Res.isInvalid())
  return ExprError();
E = Res.get();

// If this is a 'float'  or '__fp16' (CVR qualified or typedef)
// promote to double.
// Note that default argument promotion applies only to float (and
// half/fp16); it does not apply to _Float16.
const BuiltinType *BTy = Ty->getAs<BuiltinType>();
if (BTy && (BTy->getKind() == BuiltinType::Half ||
            BTy->getKind() == BuiltinType::Float)) {
  if (getLangOpts().OpenCL &&
      !getOpenCLOptions().isAvailableOption("cl_khr_fp64", getLangOpts())) {
    if (BTy->getKind() == BuiltinType::Half) {
      E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
    }
  } else {
    E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();
  }
}
if (BTy &&
    getLangOpts().getExtendIntArgs() ==
        LangOptions::ExtendArgsKind::ExtendTo64 &&
    Context.getTargetInfo().supportsExtendIntArgs() && Ty->isIntegerType() &&
    Context.getTypeSizeInChars(BTy) <
        Context.getTypeSizeInChars(Context.LongLongTy)) {
  E = (Ty->isUnsignedIntegerType())
          ? ImpCastExprToType(E, Context.UnsignedLongLongTy, CK_IntegralCast)
                .get()
          : ImpCastExprToType(E, Context.LongLongTy, CK_IntegralCast).get();
  assert(8 == Context.getTypeSizeInChars(Context.LongLongTy).getQuantity() &&(static_cast <bool> (8 == Context.getTypeSizeInChars(Context
.LongLongTy).getQuantity() && "Unexpected typesize for LongLongTy"
) ? void (0) : __assert_fail ("8 == Context.getTypeSizeInChars(Context.LongLongTy).getQuantity() && \"Unexpected typesize for LongLongTy\""
, "clang/lib/Sema/SemaExpr.cpp", 892, __extension__ __PRETTY_FUNCTION__
))
         "Unexpected typesize for LongLongTy")(static_cast <bool> (8 == Context.getTypeSizeInChars(Context
.LongLongTy).getQuantity() && "Unexpected typesize for LongLongTy"
) ? void (0) : __assert_fail ("8 == Context.getTypeSizeInChars(Context.LongLongTy).getQuantity() && \"Unexpected typesize for LongLongTy\""
, "clang/lib/Sema/SemaExpr.cpp", 892, __extension__ __PRETTY_FUNCTION__
));
}

// C++ performs lvalue-to-rvalue conversion as a default argument
// promotion, even on class types, but note:
//   C++11 [conv.lval]p2:
//     When an lvalue-to-rvalue conversion occurs in an unevaluated
//     operand or a subexpression thereof the value contained in the
//     referenced object is not accessed. Otherwise, if the glvalue
//     has a class type, the conversion copy-initializes a temporary
//     of type T from the glvalue and the result of the conversion
//     is a prvalue for the temporary.
// FIXME: add some way to gate this entire thing for correctness in
// potentially potentially evaluated contexts.
if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) {
  ExprResult Temp = PerformCopyInitialization(
                     InitializedEntity::InitializeTemporary(E->getType()),
                                              E->getExprLoc(), E);
  if (Temp.isInvalid())
    return ExprError();
  E = Temp.get();
}

return E;
916}

918/// Determine the degree of POD-ness for an expression.
919/// Incomplete types are considered POD, since this check can be performed
920/// when we're in an unevaluated context.
921Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
if (Ty->isIncompleteType()) {
  // C++11 [expr.call]p7:
  //   After these conversions, if the argument does not have arithmetic,
  //   enumeration, pointer, pointer to member, or class type, the program
  //   is ill-formed.
  //
  // Since we've already performed array-to-pointer and function-to-pointer
  // decay, the only such type in C++ is cv void. This also handles
  // initializer lists as variadic arguments.
  if (Ty->isVoidType())
    return VAK_Invalid;

  if (Ty->isObjCObjectType())
    return VAK_Invalid;
  return VAK_Valid;
}

if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
  return VAK_Invalid;

if (Context.getTargetInfo().getTriple().isWasm() &&
    Ty->isWebAssemblyReferenceType()) {
  return VAK_Invalid;
}

if (Ty.isCXX98PODType(Context))
  return VAK_Valid;

// C++11 [expr.call]p7:
//   Passing a potentially-evaluated argument of class type (Clause 9)
//   having a non-trivial copy constructor, a non-trivial move constructor,
//   or a non-trivial destructor, with no corresponding parameter,
//   is conditionally-supported with implementation-defined semantics.
if (getLangOpts().CPlusPlus11 && !Ty->isDependentType())
  if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl())
    if (!Record->hasNonTrivialCopyConstructor() &&
        !Record->hasNonTrivialMoveConstructor() &&
        !Record->hasNonTrivialDestructor())
      return VAK_ValidInCXX11;

if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType())
  return VAK_Valid;

if (Ty->isObjCObjectType())
  return VAK_Invalid;

if (getLangOpts().MSVCCompat)
  return VAK_MSVCUndefined;

// FIXME: In C++11, these cases are conditionally-supported, meaning we're
// permitted to reject them. We should consider doing so.
return VAK_Undefined;
974}

976void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
// Don't allow one to pass an Objective-C interface to a vararg.
const QualType &Ty = E->getType();
VarArgKind VAK = isValidVarArgType(Ty);

// Complain about passing non-POD types through varargs.
switch (VAK) {
case VAK_ValidInCXX11:
  DiagRuntimeBehavior(
      E->getBeginLoc(), nullptr,
      PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
  [[fallthrough]];
case VAK_Valid:
  if (Ty->isRecordType()) {
    // This is unlikely to be what the user intended. If the class has a
    // 'c_str' member function, the user probably meant to call that.
    DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
                        PDiag(diag::warn_pass_class_arg_to_vararg)
                            << Ty << CT << hasCStrMethod(E) << ".c_str()");
  }
  break;

case VAK_Undefined:
case VAK_MSVCUndefined:
  DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
                      PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
                          << getLangOpts().CPlusPlus11 << Ty << CT);
  break;

case VAK_Invalid:
  if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
    Diag(E->getBeginLoc(),
         diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
        << Ty << CT;
  else if (Ty->isObjCObjectType())
    DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
                        PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
                            << Ty << CT);
  else
    Diag(E->getBeginLoc(), diag::err_cannot_pass_to_vararg)
        << isa<InitListExpr>(E) << Ty << CT;
  break;
}
1019}

1021/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
1022/// will create a trap if the resulting type is not a POD type.
1023ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
                                                FunctionDecl *FDecl) {
if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) {
  // Strip the unbridged-cast placeholder expression off, if applicable.
  if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
      (CT == VariadicMethod ||
       (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) {
    E = stripARCUnbridgedCast(E);

  // Otherwise, do normal placeholder checking.
  } else {
    ExprResult ExprRes = CheckPlaceholderExpr(E);
    if (ExprRes.isInvalid())
      return ExprError();
    E = ExprRes.get();
  }
}

ExprResult ExprRes = DefaultArgumentPromotion(E);
if (ExprRes.isInvalid())
  return ExprError();

// Copy blocks to the heap.
if (ExprRes.get()->getType()->isBlockPointerType())
  maybeExtendBlockObject(ExprRes);

E = ExprRes.get();

// Diagnostics regarding non-POD argument types are
// emitted along with format string checking in Sema::CheckFunctionCall().
if (isValidVarArgType(E->getType()) == VAK_Undefined) {
  // Turn this into a trap.
  CXXScopeSpec SS;
  SourceLocation TemplateKWLoc;
  UnqualifiedId Name;
  Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"),
                     E->getBeginLoc());
  ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, Name,
                                        /*HasTrailingLParen=*/true,
                                        /*IsAddressOfOperand=*/false);
  if (TrapFn.isInvalid())
    return ExprError();

  ExprResult Call = BuildCallExpr(TUScope, TrapFn.get(), E->getBeginLoc(),
                                  std::nullopt, E->getEndLoc());
  if (Call.isInvalid())
    return ExprError();

  ExprResult Comma =
      ActOnBinOp(TUScope, E->getBeginLoc(), tok::comma, Call.get(), E);
  if (Comma.isInvalid())
    return ExprError();
  return Comma.get();
}

if (!getLangOpts().CPlusPlus &&
    RequireCompleteType(E->getExprLoc(), E->getType(),
                        diag::err_call_incomplete_argument))
  return ExprError();

return E;
1084}

1086/// Converts an integer to complex float type.  Helper function of
1087/// UsualArithmeticConversions()
1088///
1089/// \return false if the integer expression is an integer type and is
1090/// successfully converted to the complex type.
1091static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr,
                                                ExprResult &ComplexExpr,
                                                QualType IntTy,
                                                QualType ComplexTy,
                                                bool SkipCast) {
if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
if (SkipCast) return false;
if (IntTy->isIntegerType()) {
  QualType fpTy = ComplexTy->castAs<ComplexType>()->getElementType();
  IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                CK_FloatingRealToComplex);
} else {
  assert(IntTy->isComplexIntegerType())(static_cast <bool> (IntTy->isComplexIntegerType()) ?
 void (0) : __assert_fail ("IntTy->isComplexIntegerType()"
, "clang/lib/Sema/SemaExpr.cpp", 1104, __extension__ __PRETTY_FUNCTION__
));
  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                CK_IntegralComplexToFloatingComplex);
}
return false;
1109}

1111// This handles complex/complex, complex/float, or float/complex.
1112// When both operands are complex, the shorter operand is converted to the
1113// type of the longer, and that is the type of the result. This corresponds
1114// to what is done when combining two real floating-point operands.
1115// The fun begins when size promotion occur across type domains.
1116// From H&S 6.3.4: When one operand is complex and the other is a real
1117// floating-point type, the less precise type is converted, within it's
1118// real or complex domain, to the precision of the other type. For example,
1119// when combining a "long double" with a "double _Complex", the
1120// "double _Complex" is promoted to "long double _Complex".
1121static QualType handleComplexFloatConversion(Sema &S, ExprResult &Shorter,
                                           QualType ShorterType,
                                           QualType LongerType,
                                           bool PromotePrecision) {
bool LongerIsComplex = isa<ComplexType>(LongerType.getCanonicalType());
QualType Result =
    LongerIsComplex ? LongerType : S.Context.getComplexType(LongerType);

if (PromotePrecision) {
  if (isa<ComplexType>(ShorterType.getCanonicalType())) {
    Shorter =
        S.ImpCastExprToType(Shorter.get(), Result, CK_FloatingComplexCast);
  } else {
    if (LongerIsComplex)
      LongerType = LongerType->castAs<ComplexType>()->getElementType();
    Shorter = S.ImpCastExprToType(Shorter.get(), LongerType, CK_FloatingCast);
  }
}
return Result;
1140}

1142/// Handle arithmetic conversion with complex types.  Helper function of
1143/// UsualArithmeticConversions()
1144static QualType handleComplexConversion(Sema &S, ExprResult &LHS,
                                      ExprResult &RHS, QualType LHSType,
                                      QualType RHSType, bool IsCompAssign) {
// if we have an integer operand, the result is the complex type.
if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                           /*SkipCast=*/false))
  return LHSType;
if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
                                           /*SkipCast=*/IsCompAssign))
  return RHSType;

// Compute the rank of the two types, regardless of whether they are complex.
int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
if (Order < 0)
  // Promote the precision of the LHS if not an assignment.
  return handleComplexFloatConversion(S, LHS, LHSType, RHSType,
                                      /*PromotePrecision=*/!IsCompAssign);
// Promote the precision of the RHS unless it is already the same as the LHS.
return handleComplexFloatConversion(S, RHS, RHSType, LHSType,
                                    /*PromotePrecision=*/Order > 0);
1164}

1166/// Handle arithmetic conversion from integer to float.  Helper function
1167/// of UsualArithmeticConversions()
1168static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
                                         ExprResult &IntExpr,
                                         QualType FloatTy, QualType IntTy,
                                         bool ConvertFloat, bool ConvertInt) {
if (IntTy->isIntegerType()) {
  if (ConvertInt)
    // Convert intExpr to the lhs floating point type.
    IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy,
                                  CK_IntegralToFloating);
  return FloatTy;
}

// Convert both sides to the appropriate complex float.
assert(IntTy->isComplexIntegerType())(static_cast <bool> (IntTy->isComplexIntegerType()) ?
 void (0) : __assert_fail ("IntTy->isComplexIntegerType()"
, "clang/lib/Sema/SemaExpr.cpp", 1181, __extension__ __PRETTY_FUNCTION__
));
QualType result = S.Context.getComplexType(FloatTy);

// _Complex int -> _Complex float
if (ConvertInt)
  IntExpr = S.ImpCastExprToType(IntExpr.get(), result,
                                CK_IntegralComplexToFloatingComplex);

// float -> _Complex float
if (ConvertFloat)
  FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result,
                                  CK_FloatingRealToComplex);

return result;
1195}

1197/// Handle arithmethic conversion with floating point types.  Helper
1198/// function of UsualArithmeticConversions()
1199static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
                                    ExprResult &RHS, QualType LHSType,
                                    QualType RHSType, bool IsCompAssign) {
bool LHSFloat = LHSType->isRealFloatingType();
bool RHSFloat = RHSType->isRealFloatingType();

// N1169 4.1.4: If one of the operands has a floating type and the other
//              operand has a fixed-point type, the fixed-point operand
//              is converted to the floating type [...]
if (LHSType->isFixedPointType() || RHSType->isFixedPointType()) {
  if (LHSFloat)
    RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FixedPointToFloating);
  else if (!IsCompAssign)
    LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FixedPointToFloating);
  return LHSFloat ? LHSType : RHSType;
}

// If we have two real floating types, convert the smaller operand
// to the bigger result.
if (LHSFloat && RHSFloat) {
  int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
  if (order > 0) {
    RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast);
    return LHSType;
  }

  assert(order < 0 && "illegal float comparison")(static_cast <bool> (order < 0 && "illegal float comparison"
) ? void (0) : __assert_fail ("order < 0 && \"illegal float comparison\""
, "clang/lib/Sema/SemaExpr.cpp", 1225, __extension__ __PRETTY_FUNCTION__
));
  if (!IsCompAssign)
    LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast);
  return RHSType;
}

if (LHSFloat) {
  // Half FP has to be promoted to float unless it is natively supported
  if (LHSType->isHalfType() && !S.getLangOpts().NativeHalfType)
    LHSType = S.Context.FloatTy;

  return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
                                    /*ConvertFloat=*/!IsCompAssign,
                                    /*ConvertInt=*/ true);
}
assert(RHSFloat)(static_cast <bool> (RHSFloat) ? void (0) : __assert_fail
 ("RHSFloat", "clang/lib/Sema/SemaExpr.cpp", 1240, __extension__
 __PRETTY_FUNCTION__));
return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                  /*ConvertFloat=*/ true,
                                  /*ConvertInt=*/!IsCompAssign);
1244}

1246/// Diagnose attempts to convert between __float128, __ibm128 and
1247/// long double if there is no support for such conversion.
1248/// Helper function of UsualArithmeticConversions().
1249static bool unsupportedTypeConversion(const Sema &S, QualType LHSType,
                                    QualType RHSType) {
// No issue if either is not a floating point type.
if (!LHSType->isFloatingType() || !RHSType->isFloatingType())
  return false;

// No issue if both have the same 128-bit float semantics.
auto *LHSComplex = LHSType->getAs<ComplexType>();
auto *RHSComplex = RHSType->getAs<ComplexType>();

QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
QualType RHSElem = RHSComplex ? RHSComplex->getElementType() : RHSType;

const llvm::fltSemantics &LHSSem = S.Context.getFloatTypeSemantics(LHSElem);
const llvm::fltSemantics &RHSSem = S.Context.getFloatTypeSemantics(RHSElem);

if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
     &RHSSem != &llvm::APFloat::IEEEquad()) &&
    (&LHSSem != &llvm::APFloat::IEEEquad() ||
     &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
  return false;

return true;
1272}

1274typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);

1276namespace {
1277/// These helper callbacks are placed in an anonymous namespace to
1278/// permit their use as function template parameters.
1279ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, toType, CK_IntegralCast);
1281}

1283ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
                           CK_IntegralComplexCast);
1286}
1287}

1289/// Handle integer arithmetic conversions.  Helper function of
1290/// UsualArithmeticConversions()
1291template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1292static QualType handleIntegerConversion(Sema &S, ExprResult &LHS,
                                      ExprResult &RHS, QualType LHSType,
                                      QualType RHSType, bool IsCompAssign) {
// The rules for this case are in C99 6.3.1.8
int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
bool LHSSigned = LHSType->hasSignedIntegerRepresentation();
bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
if (LHSSigned == RHSSigned) {
  // Same signedness; use the higher-ranked type
  if (order >= 0) {
    RHS = (*doRHSCast)(S, RHS.get(), LHSType);
    return LHSType;
  } else if (!IsCompAssign)
    LHS = (*doLHSCast)(S, LHS.get(), RHSType);
  return RHSType;
} else if (order != (LHSSigned ? 1 : -1)) {
  // The unsigned type has greater than or equal rank to the
  // signed type, so use the unsigned type
  if (RHSSigned) {
    RHS = (*doRHSCast)(S, RHS.get(), LHSType);
    return LHSType;
  } else if (!IsCompAssign)
    LHS = (*doLHSCast)(S, LHS.get(), RHSType);
  return RHSType;
} else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) {
  // The two types are different widths; if we are here, that
  // means the signed type is larger than the unsigned type, so
  // use the signed type.
  if (LHSSigned) {
    RHS = (*doRHSCast)(S, RHS.get(), LHSType);
    return LHSType;
  } else if (!IsCompAssign)
    LHS = (*doLHSCast)(S, LHS.get(), RHSType);
  return RHSType;
} else {
  // The signed type is higher-ranked than the unsigned type,
  // but isn't actually any bigger (like unsigned int and long
  // on most 32-bit systems).  Use the unsigned type corresponding
  // to the signed type.
  QualType result =
    S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
  RHS = (*doRHSCast)(S, RHS.get(), result);
  if (!IsCompAssign)
    LHS = (*doLHSCast)(S, LHS.get(), result);
  return result;
}
1338}

1340/// Handle conversions with GCC complex int extension.  Helper function
1341/// of UsualArithmeticConversions()
1342static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
                                         ExprResult &RHS, QualType LHSType,
                                         QualType RHSType,
                                         bool IsCompAssign) {
const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType();
const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType();

if (LHSComplexInt && RHSComplexInt) {
  QualType LHSEltType = LHSComplexInt->getElementType();
  QualType RHSEltType = RHSComplexInt->getElementType();
  QualType ScalarType =
    handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
      (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);

  return S.Context.getComplexType(ScalarType);
}

if (LHSComplexInt) {
  QualType LHSEltType = LHSComplexInt->getElementType();
  QualType ScalarType =
    handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
      (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
  QualType ComplexType = S.Context.getComplexType(ScalarType);
  RHS = S.ImpCastExprToType(RHS.get(), ComplexType,
                            CK_IntegralRealToComplex);

  return ComplexType;
}

assert(RHSComplexInt)(static_cast <bool> (RHSComplexInt) ? void (0) : __assert_fail
 ("RHSComplexInt", "clang/lib/Sema/SemaExpr.cpp", 1371, __extension__
 __PRETTY_FUNCTION__));

QualType RHSEltType = RHSComplexInt->getElementType();
QualType ScalarType =
  handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
    (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
QualType ComplexType = S.Context.getComplexType(ScalarType);

if (!IsCompAssign)
  LHS = S.ImpCastExprToType(LHS.get(), ComplexType,
                            CK_IntegralRealToComplex);
return ComplexType;
1383}

1385/// Return the rank of a given fixed point or integer type. The value itself
1386/// doesn't matter, but the values must be increasing with proper increasing
1387/// rank as described in N1169 4.1.1.
1388static unsigned GetFixedPointRank(QualType Ty) {
const auto *BTy = Ty->getAs<BuiltinType>();
assert(BTy && "Expected a builtin type.")(static_cast <bool> (BTy && "Expected a builtin type."
) ? void (0) : __assert_fail ("BTy && \"Expected a builtin type.\""
, "clang/lib/Sema/SemaExpr.cpp", 1390, __extension__ __PRETTY_FUNCTION__
));

switch (BTy->getKind()) {
case BuiltinType::ShortFract:
case BuiltinType::UShortFract:
case BuiltinType::SatShortFract:
case BuiltinType::SatUShortFract:
  return 1;
case BuiltinType::Fract:
case BuiltinType::UFract:
case BuiltinType::SatFract:
case BuiltinType::SatUFract:
  return 2;
case BuiltinType::LongFract:
case BuiltinType::ULongFract:
case BuiltinType::SatLongFract:
case BuiltinType::SatULongFract:
  return 3;
case BuiltinType::ShortAccum:
case BuiltinType::UShortAccum:
case BuiltinType::SatShortAccum:
case BuiltinType::SatUShortAccum:
  return 4;
case BuiltinType::Accum:
case BuiltinType::UAccum:
case BuiltinType::SatAccum:
case BuiltinType::SatUAccum:
  return 5;
case BuiltinType::LongAccum:
case BuiltinType::ULongAccum:
case BuiltinType::SatLongAccum:
case BuiltinType::SatULongAccum:
  return 6;
default:
  if (BTy->isInteger())
    return 0;
  llvm_unreachable("Unexpected fixed point or integer type")::llvm::llvm_unreachable_internal("Unexpected fixed point or integer type"
, "clang/lib/Sema/SemaExpr.cpp", 1426);
}
1428}

1430/// handleFixedPointConversion - Fixed point operations between fixed
1431/// point types and integers or other fixed point types do not fall under
1432/// usual arithmetic conversion since these conversions could result in loss
1433/// of precsision (N1169 4.1.4). These operations should be calculated with
1434/// the full precision of their result type (N1169 4.1.6.2.1).
1435static QualType handleFixedPointConversion(Sema &S, QualType LHSTy,
                                         QualType RHSTy) {
assert((LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) &&(static_cast <bool> ((LHSTy->isFixedPointType() || RHSTy
->isFixedPointType()) && "Expected at least one of the operands to be a fixed point type"
) ? void (0) : __assert_fail ("(LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) && \"Expected at least one of the operands to be a fixed point type\""
, "clang/lib/Sema/SemaExpr.cpp", 1438, __extension__ __PRETTY_FUNCTION__
))
       "Expected at least one of the operands to be a fixed point type")(static_cast <bool> ((LHSTy->isFixedPointType() || RHSTy
->isFixedPointType()) && "Expected at least one of the operands to be a fixed point type"
) ? void (0) : __assert_fail ("(LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) && \"Expected at least one of the operands to be a fixed point type\""
, "clang/lib/Sema/SemaExpr.cpp", 1438, __extension__ __PRETTY_FUNCTION__
));
assert((LHSTy->isFixedPointOrIntegerType() ||(static_cast <bool> ((LHSTy->isFixedPointOrIntegerType
() || RHSTy->isFixedPointOrIntegerType()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? void (0) : __assert_fail
 ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "clang/lib/Sema/SemaExpr.cpp", 1442, __extension__ __PRETTY_FUNCTION__
))
        RHSTy->isFixedPointOrIntegerType()) &&(static_cast <bool> ((LHSTy->isFixedPointOrIntegerType
() || RHSTy->isFixedPointOrIntegerType()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? void (0) : __assert_fail
 ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "clang/lib/Sema/SemaExpr.cpp", 1442, __extension__ __PRETTY_FUNCTION__
))
       "Special fixed point arithmetic operation conversions are only "(static_cast <bool> ((LHSTy->isFixedPointOrIntegerType
() || RHSTy->isFixedPointOrIntegerType()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? void (0) : __assert_fail
 ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "clang/lib/Sema/SemaExpr.cpp", 1442, __extension__ __PRETTY_FUNCTION__
))
       "applied to ints or other fixed point types")(static_cast <bool> ((LHSTy->isFixedPointOrIntegerType
() || RHSTy->isFixedPointOrIntegerType()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? void (0) : __assert_fail
 ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "clang/lib/Sema/SemaExpr.cpp", 1442, __extension__ __PRETTY_FUNCTION__
));

// If one operand has signed fixed-point type and the other operand has
// unsigned fixed-point type, then the unsigned fixed-point operand is
// converted to its corresponding signed fixed-point type and the resulting
// type is the type of the converted operand.
if (RHSTy->isSignedFixedPointType() && LHSTy->isUnsignedFixedPointType())
  LHSTy = S.Context.getCorrespondingSignedFixedPointType(LHSTy);
else if (RHSTy->isUnsignedFixedPointType() && LHSTy->isSignedFixedPointType())
  RHSTy = S.Context.getCorrespondingSignedFixedPointType(RHSTy);

// The result type is the type with the highest rank, whereby a fixed-point
// conversion rank is always greater than an integer conversion rank; if the
// type of either of the operands is a saturating fixedpoint type, the result
// type shall be the saturating fixed-point type corresponding to the type
// with the highest rank; the resulting value is converted (taking into
// account rounding and overflow) to the precision of the resulting type.
// Same ranks between signed and unsigned types are resolved earlier, so both
// types are either signed or both unsigned at this point.
unsigned LHSTyRank = GetFixedPointRank(LHSTy);
unsigned RHSTyRank = GetFixedPointRank(RHSTy);

QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;

if (LHSTy->isSaturatedFixedPointType() || RHSTy->isSaturatedFixedPointType())
  ResultTy = S.Context.getCorrespondingSaturatedType(ResultTy);

return ResultTy;
1470}

1472/// Check that the usual arithmetic conversions can be performed on this pair of
1473/// expressions that might be of enumeration type.
1474static void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS,
                                         SourceLocation Loc,
                                         Sema::ArithConvKind ACK) {
// C++2a [expr.arith.conv]p1:
//   If one operand is of enumeration type and the other operand is of a
//   different enumeration type or a floating-point type, this behavior is
//   deprecated ([depr.arith.conv.enum]).
//
// Warn on this in all language modes. Produce a deprecation warning in C++20.
// Eventually we will presumably reject these cases (in C++23 onwards?).
QualType L = LHS->getType(), R = RHS->getType();
bool LEnum = L->isUnscopedEnumerationType(),
     REnum = R->isUnscopedEnumerationType();
bool IsCompAssign = ACK == Sema::ACK_CompAssign;
if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
    (REnum && L->isFloatingType())) {
  S.Diag(Loc, S.getLangOpts().CPlusPlus20
                  ? diag::warn_arith_conv_enum_float_cxx20
                  : diag::warn_arith_conv_enum_float)
      << LHS->getSourceRange() << RHS->getSourceRange()
      << (int)ACK << LEnum << L << R;
} else if (!IsCompAssign && LEnum && REnum &&
           !S.Context.hasSameUnqualifiedType(L, R)) {
  unsigned DiagID;
  if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() ||
      !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {
    // If either enumeration type is unnamed, it's less likely that the
    // user cares about this, but this situation is still deprecated in
    // C++2a. Use a different warning group.
    DiagID = S.getLangOpts().CPlusPlus20
                  ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20
                  : diag::warn_arith_conv_mixed_anon_enum_types;
  } else if (ACK == Sema::ACK_Conditional) {
    // Conditional expressions are separated out because they have
    // historically had a different warning flag.
    DiagID = S.getLangOpts().CPlusPlus20
                 ? diag::warn_conditional_mixed_enum_types_cxx20
                 : diag::warn_conditional_mixed_enum_types;
  } else if (ACK == Sema::ACK_Comparison) {
    // Comparison expressions are separated out because they have
    // historically had a different warning flag.
    DiagID = S.getLangOpts().CPlusPlus20
                 ? diag::warn_comparison_mixed_enum_types_cxx20
                 : diag::warn_comparison_mixed_enum_types;
  } else {
    DiagID = S.getLangOpts().CPlusPlus20
                 ? diag::warn_arith_conv_mixed_enum_types_cxx20
                 : diag::warn_arith_conv_mixed_enum_types;
  }
  S.Diag(Loc, DiagID) << LHS->getSourceRange() << RHS->getSourceRange()
                      << (int)ACK << L << R;
}
1526}

1528/// UsualArithmeticConversions - Performs various conversions that are common to
1529/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
1530/// routine returns the first non-arithmetic type found. The client is
1531/// responsible for emitting appropriate error diagnostics.
1532QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
                                        SourceLocation Loc,
                                        ArithConvKind ACK) {
checkEnumArithmeticConversions(*this, LHS.get(), RHS.get(), Loc, ACK);

if (ACK != ACK_CompAssign) {
  LHS = UsualUnaryConversions(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}

RHS = UsualUnaryConversions(RHS.get());
if (RHS.isInvalid())
  return QualType();

// For conversion purposes, we ignore any qualifiers.
// For example, "const float" and "float" are equivalent.
QualType LHSType = LHS.get()->getType().getUnqualifiedType();
QualType RHSType = RHS.get()->getType().getUnqualifiedType();

// For conversion purposes, we ignore any atomic qualifier on the LHS.
if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>())
  LHSType = AtomicLHS->getValueType();

// If both types are identical, no conversion is needed.
if (Context.hasSameType(LHSType, RHSType))
  return Context.getCommonSugaredType(LHSType, RHSType);

// If either side is a non-arithmetic type (e.g. a pointer), we are done.
// The caller can deal with this (e.g. pointer + int).
if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
  return QualType();

// Apply unary and bitfield promotions to the LHS's type.
QualType LHSUnpromotedType = LHSType;
if (Context.isPromotableIntegerType(LHSType))
  LHSType = Context.getPromotedIntegerType(LHSType);
QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get());
if (!LHSBitfieldPromoteTy.isNull())
  LHSType = LHSBitfieldPromoteTy;
if (LHSType != LHSUnpromotedType && ACK != ACK_CompAssign)
  LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);

// If both types are identical, no conversion is needed.
if (Context.hasSameType(LHSType, RHSType))
  return Context.getCommonSugaredType(LHSType, RHSType);

// At this point, we have two different arithmetic types.

// Diagnose attempts to convert between __ibm128, __float128 and long double
// where such conversions currently can't be handled.
if (unsupportedTypeConversion(*this, LHSType, RHSType))
  return QualType();

// Handle complex types first (C99 6.3.1.8p1).
if (LHSType->isComplexType() || RHSType->isComplexType())
  return handleComplexConversion(*this, LHS, RHS, LHSType, RHSType,
                                 ACK == ACK_CompAssign);

// Now handle "real" floating types (i.e. float, double, long double).
if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
  return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
                               ACK == ACK_CompAssign);

// Handle GCC complex int extension.
if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
  return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
                                    ACK == ACK_CompAssign);

if (LHSType->isFixedPointType() || RHSType->isFixedPointType())
  return handleFixedPointConversion(*this, LHSType, RHSType);

// Finally, we have two differing integer types.
return handleIntegerConversion<doIntegralCast, doIntegralCast>
         (*this, LHS, RHS, LHSType, RHSType, ACK == ACK_CompAssign);
1607}

1609//===----------------------------------------------------------------------===//
1610//  Semantic Analysis for various Expression Types
1611//===----------------------------------------------------------------------===//


1614ExprResult
1615Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
                              SourceLocation DefaultLoc,
                              SourceLocation RParenLoc,
                              Expr *ControllingExpr,
                              ArrayRef<ParsedType> ArgTypes,
                              ArrayRef<Expr *> ArgExprs) {
unsigned NumAssocs = ArgTypes.size();
assert(NumAssocs == ArgExprs.size())(static_cast <bool> (NumAssocs == ArgExprs.size()) ? void
 (0) : __assert_fail ("NumAssocs == ArgExprs.size()", "clang/lib/Sema/SemaExpr.cpp"
, 1622, __extension__ __PRETTY_FUNCTION__));

TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
for (unsigned i = 0; i < NumAssocs; ++i) {
  if (ArgTypes[i])
    (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
  else
    Types[i] = nullptr;
}

ExprResult ER =
    CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, ControllingExpr,
                               llvm::ArrayRef(Types, NumAssocs), ArgExprs);
delete [] Types;
return ER;
1637}

1639ExprResult
1640Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc,
                               SourceLocation DefaultLoc,
                               SourceLocation RParenLoc,
                               Expr *ControllingExpr,
                               ArrayRef<TypeSourceInfo *> Types,
                               ArrayRef<Expr *> Exprs) {
unsigned NumAssocs = Types.size();
assert(NumAssocs == Exprs.size())(static_cast <bool> (NumAssocs == Exprs.size()) ? void (
0) : __assert_fail ("NumAssocs == Exprs.size()", "clang/lib/Sema/SemaExpr.cpp"
, 1647, __extension__ __PRETTY_FUNCTION__));

// Decay and strip qualifiers for the controlling expression type, and handle
// placeholder type replacement. See committee discussion from WG14 DR423.
{
  EnterExpressionEvaluationContext Unevaluated(
      *this, Sema::ExpressionEvaluationContext::Unevaluated);
  ExprResult R = DefaultFunctionArrayLvalueConversion(ControllingExpr);
  if (R.isInvalid())
    return ExprError();
  ControllingExpr = R.get();
}

bool TypeErrorFound = false,
     IsResultDependent = ControllingExpr->isTypeDependent(),
     ContainsUnexpandedParameterPack
       = ControllingExpr->containsUnexpandedParameterPack();

// The controlling expression is an unevaluated operand, so side effects are
// likely unintended.
if (!inTemplateInstantiation() && !IsResultDependent &&
    ControllingExpr->HasSideEffects(Context, false))
  Diag(ControllingExpr->getExprLoc(),
       diag::warn_side_effects_unevaluated_context);

for (unsigned i = 0; i < NumAssocs; ++i) {
  if (Exprs[i]->containsUnexpandedParameterPack())
    ContainsUnexpandedParameterPack = true;

  if (Types[i]) {
    if (Types[i]->getType()->containsUnexpandedParameterPack())
      ContainsUnexpandedParameterPack = true;

    if (Types[i]->getType()->isDependentType()) {
      IsResultDependent = true;
    } else {
      // C11 6.5.1.1p2 "The type name in a generic association shall specify a
      // complete object type other than a variably modified type."
      unsigned D = 0;
      if (Types[i]->getType()->isIncompleteType())
        D = diag::err_assoc_type_incomplete;
      else if (!Types[i]->getType()->isObjectType())
        D = diag::err_assoc_type_nonobject;
      else if (Types[i]->getType()->isVariablyModifiedType())
        D = diag::err_assoc_type_variably_modified;
      else {
        // Because the controlling expression undergoes lvalue conversion,
        // array conversion, and function conversion, an association which is
        // of array type, function type, or is qualified can never be
        // reached. We will warn about this so users are less surprised by
        // the unreachable association. However, we don't have to handle
        // function types; that's not an object type, so it's handled above.
        //
        // The logic is somewhat different for C++ because C++ has different
        // lvalue to rvalue conversion rules than C. [conv.lvalue]p1 says,
        // If T is a non-class type, the type of the prvalue is the cv-
        // unqualified version of T. Otherwise, the type of the prvalue is T.
        // The result of these rules is that all qualified types in an
        // association in C are unreachable, and in C++, only qualified non-
        // class types are unreachable.
        unsigned Reason = 0;
        QualType QT = Types[i]->getType();
        if (QT->isArrayType())
          Reason = 1;
        else if (QT.hasQualifiers() &&
                 (!LangOpts.CPlusPlus || !QT->isRecordType()))
          Reason = 2;

        if (Reason)
          Diag(Types[i]->getTypeLoc().getBeginLoc(),
               diag::warn_unreachable_association)
              << QT << (Reason - 1);
      }

      if (D != 0) {
        Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
          << Types[i]->getTypeLoc().getSourceRange()
          << Types[i]->getType();
        TypeErrorFound = true;
      }

      // C11 6.5.1.1p2 "No two generic associations in the same generic
      // selection shall specify compatible types."
      for (unsigned j = i+1; j < NumAssocs; ++j)
        if (Types[j] && !Types[j]->getType()->isDependentType() &&
            Context.typesAreCompatible(Types[i]->getType(),
                                       Types[j]->getType())) {
          Diag(Types[j]->getTypeLoc().getBeginLoc(),
               diag::err_assoc_compatible_types)
            << Types[j]->getTypeLoc().getSourceRange()
            << Types[j]->getType()
            << Types[i]->getType();
          Diag(Types[i]->getTypeLoc().getBeginLoc(),
               diag::note_compat_assoc)
            << Types[i]->getTypeLoc().getSourceRange()
            << Types[i]->getType();
          TypeErrorFound = true;
        }
    }
  }
}
if (TypeErrorFound)
  return ExprError();

// If we determined that the generic selection is result-dependent, don't
// try to compute the result expression.
if (IsResultDependent)
  return GenericSelectionExpr::Create(Context, KeyLoc, ControllingExpr, Types,
                                      Exprs, DefaultLoc, RParenLoc,
                                      ContainsUnexpandedParameterPack);

SmallVector<unsigned, 1> CompatIndices;
unsigned DefaultIndex = -1U;
// Look at the canonical type of the controlling expression in case it was a
// deduced type like __auto_type. However, when issuing diagnostics, use the
// type the user wrote in source rather than the canonical one.
for (unsigned i = 0; i < NumAssocs; ++i) {
  if (!Types[i])
    DefaultIndex = i;
  else if (Context.typesAreCompatible(
               ControllingExpr->getType().getCanonicalType(),
                                      Types[i]->getType()))
    CompatIndices.push_back(i);
}

// C11 6.5.1.1p2 "The controlling expression of a generic selection shall have
// type compatible with at most one of the types named in its generic
// association list."
if (CompatIndices.size() > 1) {
  // We strip parens here because the controlling expression is typically
  // parenthesized in macro definitions.
  ControllingExpr = ControllingExpr->IgnoreParens();
  Diag(ControllingExpr->getBeginLoc(), diag::err_generic_sel_multi_match)
      << ControllingExpr->getSourceRange() << ControllingExpr->getType()
      << (unsigned)CompatIndices.size();
  for (unsigned I : CompatIndices) {
    Diag(Types[I]->getTypeLoc().getBeginLoc(),
         diag::note_compat_assoc)
      << Types[I]->getTypeLoc().getSourceRange()
      << Types[I]->getType();
  }
  return ExprError();
}

// C11 6.5.1.1p2 "If a generic selection has no default generic association,
// its controlling expression shall have type compatible with exactly one of
// the types named in its generic association list."
if (DefaultIndex == -1U && CompatIndices.size() == 0) {
  // We strip parens here because the controlling expression is typically
  // parenthesized in macro definitions.
  ControllingExpr = ControllingExpr->IgnoreParens();
  Diag(ControllingExpr->getBeginLoc(), diag::err_generic_sel_no_match)
      << ControllingExpr->getSourceRange() << ControllingExpr->getType();
  return ExprError();
}

// C11 6.5.1.1p3 "If a generic selection has a generic association with a
// type name that is compatible with the type of the controlling expression,
// then the result expression of the generic selection is the expression
// in that generic association. Otherwise, the result expression of the
// generic selection is the expression in the default generic association."
unsigned ResultIndex =
  CompatIndices.size() ? CompatIndices[0] : DefaultIndex;

return GenericSelectionExpr::Create(
    Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
    ContainsUnexpandedParameterPack, ResultIndex);
1814}

1816/// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the
1817/// location of the token and the offset of the ud-suffix within it.
1818static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc,
                                   unsigned Offset) {
return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(),
                                      S.getLangOpts());
1822}

1824/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up
1825/// the corresponding cooked (non-raw) literal operator, and build a call to it.
1826static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
                                               IdentifierInfo *UDSuffix,
                                               SourceLocation UDSuffixLoc,
                                               ArrayRef<Expr*> Args,
                                               SourceLocation LitEndLoc) {
assert(Args.size() <= 2 && "too many arguments for literal operator")(static_cast <bool> (Args.size() <= 2 && "too many arguments for literal operator"
) ? void (0) : __assert_fail ("Args.size() <= 2 && \"too many arguments for literal operator\""
, "clang/lib/Sema/SemaExpr.cpp", 1831, __extension__ __PRETTY_FUNCTION__
));

QualType ArgTy[2];
for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
  ArgTy[ArgIdx] = Args[ArgIdx]->getType();
  if (ArgTy[ArgIdx]->isArrayType())
    ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]);
}

DeclarationName OpName =
  S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);

LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName);
if (S.LookupLiteralOperator(Scope, R, llvm::ArrayRef(ArgTy, Args.size()),
                            /*AllowRaw*/ false, /*AllowTemplate*/ false,
                            /*AllowStringTemplatePack*/ false,
                            /*DiagnoseMissing*/ true) == Sema::LOLR_Error)
  return ExprError();

return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc);
1853}

1855/// ActOnStringLiteral - The specified tokens were lexed as pasted string
1856/// fragments (e.g. "foo" "bar" L"baz").  The result string has to handle string
1857/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1858/// multiple tokens.  However, the common case is that StringToks points to one
1859/// string.
1860///
1861ExprResult
1862Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
assert(!StringToks.empty() && "Must have at least one string!")(static_cast <bool> (!StringToks.empty() && "Must have at least one string!"
) ? void (0) : __assert_fail ("!StringToks.empty() && \"Must have at least one string!\""
, "clang/lib/Sema/SemaExpr.cpp", 1863, __extension__ __PRETTY_FUNCTION__
));

StringLiteralParser Literal(StringToks, PP);
if (Literal.hadError)
  return ExprError();

SmallVector<SourceLocation, 4> StringTokLocs;
for (const Token &Tok : StringToks)
  StringTokLocs.push_back(Tok.getLocation());

QualType CharTy = Context.CharTy;
StringLiteral::StringKind Kind = StringLiteral::Ordinary;
if (Literal.isWide()) {
  CharTy = Context.getWideCharType();
  Kind = StringLiteral::Wide;
} else if (Literal.isUTF8()) {
  if (getLangOpts().Char8)
    CharTy = Context.Char8Ty;
  Kind = StringLiteral::UTF8;
} else if (Literal.isUTF16()) {
  CharTy = Context.Char16Ty;
  Kind = StringLiteral::UTF16;
} else if (Literal.isUTF32()) {
  CharTy = Context.Char32Ty;
  Kind = StringLiteral::UTF32;
} else if (Literal.isPascal()) {
  CharTy = Context.UnsignedCharTy;
}

// Warn on initializing an array of char from a u8 string literal; this
// becomes ill-formed in C++2a.
if (getLangOpts().CPlusPlus && !getLangOpts().CPlusPlus20 &&
    !getLangOpts().Char8 && Kind == StringLiteral::UTF8) {
  Diag(StringTokLocs.front(), diag::warn_cxx20_compat_utf8_string);

  // Create removals for all 'u8' prefixes in the string literal(s). This
  // ensures C++2a compatibility (but may change the program behavior when
  // built by non-Clang compilers for which the execution character set is
  // not always UTF-8).
  auto RemovalDiag = PDiag(diag::note_cxx20_compat_utf8_string_remove_u8);
  SourceLocation RemovalDiagLoc;
  for (const Token &Tok : StringToks) {
    if (Tok.getKind() == tok::utf8_string_literal) {
      if (RemovalDiagLoc.isInvalid())
        RemovalDiagLoc = Tok.getLocation();
      RemovalDiag << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
          Tok.getLocation(),
          Lexer::AdvanceToTokenCharacter(Tok.getLocation(), 2,
                                         getSourceManager(), getLangOpts())));
    }
  }
  Diag(RemovalDiagLoc, RemovalDiag);
}

QualType StrTy =
    Context.getStringLiteralArrayType(CharTy, Literal.GetNumStringChars());

// Pass &StringTokLocs[0], StringTokLocs.size() to factory!
StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(),
                                           Kind, Literal.Pascal, StrTy,
                                           &StringTokLocs[0],
                                           StringTokLocs.size());
if (Literal.getUDSuffix().empty())
  return Lit;

// We're building a user-defined literal.
IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
  getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
                 Literal.getUDSuffixOffset());

// Make sure we're allowed user-defined literals here.
if (!UDLScope)
  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl));

// C++11 [lex.ext]p5: The literal L is treated as a call of the form
//   operator "" X (str, len)
QualType SizeType = Context.getSizeType();

DeclarationName OpName =
  Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);

QualType ArgTy[] = {
  Context.getArrayDecayedType(StrTy), SizeType
};

LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
switch (LookupLiteralOperator(UDLScope, R, ArgTy,
                              /*AllowRaw*/ false, /*AllowTemplate*/ true,
                              /*AllowStringTemplatePack*/ true,
                              /*DiagnoseMissing*/ true, Lit)) {

case LOLR_Cooked: {
  llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars());
  IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType,
                                                  StringTokLocs[0]);
  Expr *Args[] = { Lit, LenArg };

  return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back());
}

case LOLR_Template: {
  TemplateArgumentListInfo ExplicitArgs;
  TemplateArgument Arg(Lit);
  TemplateArgumentLocInfo ArgInfo(Lit);
  ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
  return BuildLiteralOperatorCall(R, OpNameInfo, std::nullopt,
                                  StringTokLocs.back(), &ExplicitArgs);
}

case LOLR_StringTemplatePack: {
  TemplateArgumentListInfo ExplicitArgs;

  unsigned CharBits = Context.getIntWidth(CharTy);
  bool CharIsUnsigned = CharTy->isUnsignedIntegerType();
  llvm::APSInt Value(CharBits, CharIsUnsigned);

  TemplateArgument TypeArg(CharTy);
  TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy));
  ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo));

  for (unsigned I = 0, N = Lit->getLength(); I != N; ++I) {
    Value = Lit->getCodeUnit(I);
    TemplateArgument Arg(Context, Value, CharTy);
    TemplateArgumentLocInfo ArgInfo;
    ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
  }
  return BuildLiteralOperatorCall(R, OpNameInfo, std::nullopt,
                                  StringTokLocs.back(), &ExplicitArgs);
}
case LOLR_Raw:
case LOLR_ErrorNoDiagnostic:
  llvm_unreachable("unexpected literal operator lookup result")::llvm::llvm_unreachable_internal("unexpected literal operator lookup result"
, "clang/lib/Sema/SemaExpr.cpp", 1997);
case LOLR_Error:
  return ExprError();
}
llvm_unreachable("unexpected literal operator lookup result")::llvm::llvm_unreachable_internal("unexpected literal operator lookup result"
, "clang/lib/Sema/SemaExpr.cpp", 2001);
2002}

2004DeclRefExpr *
2005Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                     SourceLocation Loc,
                     const CXXScopeSpec *SS) {
DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
2010}

2012DeclRefExpr *
2013Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                     const DeclarationNameInfo &NameInfo,
                     const CXXScopeSpec *SS, NamedDecl *FoundD,
                     SourceLocation TemplateKWLoc,
                     const TemplateArgumentListInfo *TemplateArgs) {
NestedNameSpecifierLoc NNS =
    SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc();
return BuildDeclRefExpr(D, Ty, VK, NameInfo, NNS, FoundD, TemplateKWLoc,
                        TemplateArgs);
2022}

2024// CUDA/HIP: Check whether a captured reference variable is referencing a
2025// host variable in a device or host device lambda.
2026static bool isCapturingReferenceToHostVarInCUDADeviceLambda(const Sema &S,
                                                          VarDecl *VD) {
if (!S.getLangOpts().CUDA || !VD->hasInit())
  return false;
assert(VD->getType()->isReferenceType())(static_cast <bool> (VD->getType()->isReferenceType
()) ? void (0) : __assert_fail ("VD->getType()->isReferenceType()"
, "clang/lib/Sema/SemaExpr.cpp", 2030, __extension__ __PRETTY_FUNCTION__
));

// Check whether the reference variable is referencing a host variable.
auto *DRE = dyn_cast<DeclRefExpr>(VD->getInit());
if (!DRE)
  return false;
auto *Referee = dyn_cast<VarDecl>(DRE->getDecl());
if (!Referee || !Referee->hasGlobalStorage() ||
    Referee->hasAttr<CUDADeviceAttr>())
  return false;

// Check whether the current function is a device or host device lambda.
// Check whether the reference variable is a capture by getDeclContext()
// since refersToEnclosingVariableOrCapture() is not ready at this point.
auto *MD = dyn_cast_or_null<CXXMethodDecl>(S.CurContext);
if (MD && MD->getParent()->isLambda() &&
    MD->getOverloadedOperator() == OO_Call && MD->hasAttr<CUDADeviceAttr>() &&
    VD->getDeclContext() != MD)
  return true;

return false;
2051}

2053NonOdrUseReason Sema::getNonOdrUseReasonInCurrentContext(ValueDecl *D) {
// A declaration named in an unevaluated operand never constitutes an odr-use.
if (isUnevaluatedContext())
  return NOUR_Unevaluated;

// C++2a [basic.def.odr]p4:
//   A variable x whose name appears as a potentially-evaluated expression e
//   is odr-used by e unless [...] x is a reference that is usable in
//   constant expressions.
// CUDA/HIP:
//   If a reference variable referencing a host variable is captured in a
//   device or host device lambda, the value of the referee must be copied
//   to the capture and the reference variable must be treated as odr-use
//   since the value of the referee is not known at compile time and must
//   be loaded from the captured.
if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
  if (VD->getType()->isReferenceType() &&
      !(getLangOpts().OpenMP && isOpenMPCapturedDecl(D)) &&
      !isCapturingReferenceToHostVarInCUDADeviceLambda(*this, VD) &&
      VD->isUsableInConstantExpressions(Context))
    return NOUR_Constant;
}

// All remaining non-variable cases constitute an odr-use. For variables, we
// need to wait and see how the expression is used.
return NOUR_None;
2079}

2081/// BuildDeclRefExpr - Build an expression that references a
2082/// declaration that does not require a closure capture.
2083DeclRefExpr *
2084Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                     const DeclarationNameInfo &NameInfo,
                     NestedNameSpecifierLoc NNS, NamedDecl *FoundD,
                     SourceLocation TemplateKWLoc,
                     const TemplateArgumentListInfo *TemplateArgs) {
bool RefersToCapturedVariable = isa<VarDecl, BindingDecl>(D) &&
                                NeedToCaptureVariable(D, NameInfo.getLoc());

DeclRefExpr *E = DeclRefExpr::Create(
    Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty,
    VK, FoundD, TemplateArgs, getNonOdrUseReasonInCurrentContext(D));
MarkDeclRefReferenced(E);

// C++ [except.spec]p17:
//   An exception-specification is considered to be needed when:
//   - in an expression, the function is the unique lookup result or
//     the selected member of a set of overloaded functions.
//
// We delay doing this until after we've built the function reference and
// marked it as used so that:
//  a) if the function is defaulted, we get errors from defining it before /
//     instead of errors from computing its exception specification, and
//  b) if the function is a defaulted comparison, we can use the body we
//     build when defining it as input to the exception specification
//     computation rather than computing a new body.
if (const auto *FPT = Ty->getAs<FunctionProtoType>()) {
  if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
    if (const auto *NewFPT = ResolveExceptionSpec(NameInfo.getLoc(), FPT))
      E->setType(Context.getQualifiedType(NewFPT, Ty.getQualifiers()));
  }
}

if (getLangOpts().ObjCWeak && isa<VarDecl>(D) &&
    Ty.getObjCLifetime() == Qualifiers::OCL_Weak && !isUnevaluatedContext() &&
    !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getBeginLoc()))
  getCurFunction()->recordUseOfWeak(E);

const auto *FD = dyn_cast<FieldDecl>(D);
if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D))
  FD = IFD->getAnonField();
if (FD) {
  UnusedPrivateFields.remove(FD);
  // Just in case we're building an illegal pointer-to-member.
  if (FD->isBitField())
    E->setObjectKind(OK_BitField);
}

// C++ [expr.prim]/8: The expression [...] is a bit-field if the identifier
// designates a bit-field.
if (const auto *BD = dyn_cast<BindingDecl>(D))
  if (const auto *BE = BD->getBinding())
    E->setObjectKind(BE->getObjectKind());

return E;
2138}

2140/// Decomposes the given name into a DeclarationNameInfo, its location, and
2141/// possibly a list of template arguments.
2142///
2143/// If this produces template arguments, it is permitted to call
2144/// DecomposeTemplateName.
2145///
2146/// This actually loses a lot of source location information for
2147/// non-standard name kinds; we should consider preserving that in
2148/// some way.
2149void
2150Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id,
                           TemplateArgumentListInfo &Buffer,
                           DeclarationNameInfo &NameInfo,
                           const TemplateArgumentListInfo *&TemplateArgs) {
if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId) {
  Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
  Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);

  ASTTemplateArgsPtr TemplateArgsPtr(Id.TemplateId->getTemplateArgs(),
                                     Id.TemplateId->NumArgs);
  translateTemplateArguments(TemplateArgsPtr, Buffer);

  TemplateName TName = Id.TemplateId->Template.get();
  SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
  NameInfo = Context.getNameForTemplate(TName, TNameLoc);
  TemplateArgs = &Buffer;
} else {
  NameInfo = GetNameFromUnqualifiedId(Id);
  TemplateArgs = nullptr;
}
2170}

2172static void emitEmptyLookupTypoDiagnostic(
  const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS,
  DeclarationName Typo, SourceLocation TypoLoc, ArrayRef<Expr *> Args,
  unsigned DiagnosticID, unsigned DiagnosticSuggestID) {
DeclContext *Ctx =
    SS.isEmpty() ? nullptr : SemaRef.computeDeclContext(SS, false);
if (!TC) {
  // Emit a special diagnostic for failed member lookups.
  // FIXME: computing the declaration context might fail here (?)
  if (Ctx)
    SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
                                               << SS.getRange();
  else
    SemaRef.Diag(TypoLoc, DiagnosticID) << Typo;
  return;
}

std::string CorrectedStr = TC.getAsString(SemaRef.getLangOpts());
bool DroppedSpecifier =
    TC.WillReplaceSpecifier() && Typo.getAsString() == CorrectedStr;
unsigned NoteID = TC.getCorrectionDeclAs<ImplicitParamDecl>()
                      ? diag::note_implicit_param_decl
                      : diag::note_previous_decl;
if (!Ctx)
  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(DiagnosticSuggestID) << Typo,
                       SemaRef.PDiag(NoteID));
else
  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
                               << Typo << Ctx << DroppedSpecifier
                               << SS.getRange(),
                       SemaRef.PDiag(NoteID));
2203}

2205/// Diagnose a lookup that found results in an enclosing class during error
2206/// recovery. This usually indicates that the results were found in a dependent
2207/// base class that could not be searched as part of a template definition.
2208/// Always issues a diagnostic (though this may be only a warning in MS
2209/// compatibility mode).
2210///
2211/// Return \c true if the error is unrecoverable, or \c false if the caller
2212/// should attempt to recover using these lookup results.
2213bool Sema::DiagnoseDependentMemberLookup(const LookupResult &R) {
// During a default argument instantiation the CurContext points
// to a CXXMethodDecl; but we can't apply a this-> fixit inside a
// function parameter list, hence add an explicit check.
bool isDefaultArgument =
    !CodeSynthesisContexts.empty() &&
    CodeSynthesisContexts.back().Kind ==
        CodeSynthesisContext::DefaultFunctionArgumentInstantiation;
const auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
bool isInstance = CurMethod && CurMethod->isInstance() &&
                  R.getNamingClass() == CurMethod->getParent() &&
                  !isDefaultArgument;

// There are two ways we can find a class-scope declaration during template
// instantiation that we did not find in the template definition: if it is a
// member of a dependent base class, or if it is declared after the point of
// use in the same class. Distinguish these by comparing the class in which
// the member was found to the naming class of the lookup.
unsigned DiagID = diag::err_found_in_dependent_base;
unsigned NoteID = diag::note_member_declared_at;
if (R.getRepresentativeDecl()->getDeclContext()->Equals(R.getNamingClass())) {
  DiagID = getLangOpts().MSVCCompat ? diag::ext_found_later_in_class
                                    : diag::err_found_later_in_class;
} else if (getLangOpts().MSVCCompat) {
  DiagID = diag::ext_found_in_dependent_base;
  NoteID = diag::note_dependent_member_use;
}

if (isInstance) {
  // Give a code modification hint to insert 'this->'.
  Diag(R.getNameLoc(), DiagID)
      << R.getLookupName()
      << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
  CheckCXXThisCapture(R.getNameLoc());
} else {
  // FIXME: Add a FixItHint to insert 'Base::' or 'Derived::' (assuming
  // they're not shadowed).
  Diag(R.getNameLoc(), DiagID) << R.getLookupName();
}

for (const NamedDecl *D : R)
  Diag(D->getLocation(), NoteID);

// Return true if we are inside a default argument instantiation
// and the found name refers to an instance member function, otherwise
// the caller will try to create an implicit member call and this is wrong
// for default arguments.
//
// FIXME: Is this special case necessary? We could allow the caller to
// diagnose this.
if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) {
  Diag(R.getNameLoc(), diag::err_member_call_without_object);
  return true;
}

// Tell the callee to try to recover.
return false;
2270}

2272/// Diagnose an empty lookup.
2273///
2274/// \return false if new lookup candidates were found
2275bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
                             CorrectionCandidateCallback &CCC,
                             TemplateArgumentListInfo *ExplicitTemplateArgs,
                             ArrayRef<Expr *> Args, TypoExpr **Out) {
DeclarationName Name = R.getLookupName();

unsigned diagnostic = diag::err_undeclared_var_use;
unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
    Name.getNameKind() == DeclarationName::CXXLiteralOperatorName ||
    Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
  diagnostic = diag::err_undeclared_use;
  diagnostic_suggest = diag::err_undeclared_use_suggest;
}

// If the original lookup was an unqualified lookup, fake an
// unqualified lookup.  This is useful when (for example) the
// original lookup would not have found something because it was a
// dependent name.
DeclContext *DC = SS.isEmpty() ? CurContext : nullptr;
while (DC) {
  if (isa<CXXRecordDecl>(DC)) {
    LookupQualifiedName(R, DC);

    if (!R.empty()) {
      // Don't give errors about ambiguities in this lookup.
      R.suppressDiagnostics();

      // If there's a best viable function among the results, only mention
      // that one in the notes.
      OverloadCandidateSet Candidates(R.getNameLoc(),
                                      OverloadCandidateSet::CSK_Normal);
      AddOverloadedCallCandidates(R, ExplicitTemplateArgs, Args, Candidates);
      OverloadCandidateSet::iterator Best;
      if (Candidates.BestViableFunction(*this, R.getNameLoc(), Best) ==
          OR_Success) {
        R.clear();
        R.addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
        R.resolveKind();
      }

      return DiagnoseDependentMemberLookup(R);
    }

    R.clear();
  }

  DC = DC->getLookupParent();
}

// We didn't find anything, so try to correct for a typo.
TypoCorrection Corrected;
if (S && Out) {
  SourceLocation TypoLoc = R.getNameLoc();
  assert(!ExplicitTemplateArgs &&(static_cast <bool> (!ExplicitTemplateArgs && "Diagnosing an empty lookup with explicit template args!"
) ? void (0) : __assert_fail ("!ExplicitTemplateArgs && \"Diagnosing an empty lookup with explicit template args!\""
, "clang/lib/Sema/SemaExpr.cpp", 2330, __extension__ __PRETTY_FUNCTION__
))
         "Diagnosing an empty lookup with explicit template args!")(static_cast <bool> (!ExplicitTemplateArgs && "Diagnosing an empty lookup with explicit template args!"
) ? void (0) : __assert_fail ("!ExplicitTemplateArgs && \"Diagnosing an empty lookup with explicit template args!\""
, "clang/lib/Sema/SemaExpr.cpp", 2330, __extension__ __PRETTY_FUNCTION__
));
  *Out = CorrectTypoDelayed(
      R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC,
      [=](const TypoCorrection &TC) {
        emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
                                      diagnostic, diagnostic_suggest);
      },
      nullptr, CTK_ErrorRecovery);
  if (*Out)
    return true;
} else if (S &&
           (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(),
                                    S, &SS, CCC, CTK_ErrorRecovery))) {
  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
  bool DroppedSpecifier =
      Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr;
  R.setLookupName(Corrected.getCorrection());

  bool AcceptableWithRecovery = false;
  bool AcceptableWithoutRecovery = false;
  NamedDecl *ND = Corrected.getFoundDecl();
  if (ND) {
    if (Corrected.isOverloaded()) {
      OverloadCandidateSet OCS(R.getNameLoc(),
                               OverloadCandidateSet::CSK_Normal);
      OverloadCandidateSet::iterator Best;
      for (NamedDecl *CD : Corrected) {
        if (FunctionTemplateDecl *FTD =
                 dyn_cast<FunctionTemplateDecl>(CD))
          AddTemplateOverloadCandidate(
              FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs,
              Args, OCS);
        else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
          if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0)
            AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none),
                                 Args, OCS);
      }
      switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) {
      case OR_Success:
        ND = Best->FoundDecl;
        Corrected.setCorrectionDecl(ND);
        break;
      default:
        // FIXME: Arbitrarily pick the first declaration for the note.
        Corrected.setCorrectionDecl(ND);
        break;
      }
    }
    R.addDecl(ND);
    if (getLangOpts().CPlusPlus && ND->isCXXClassMember()) {
      CXXRecordDecl *Record = nullptr;
      if (Corrected.getCorrectionSpecifier()) {
        const Type *Ty = Corrected.getCorrectionSpecifier()->getAsType();
        Record = Ty->getAsCXXRecordDecl();
      }
      if (!Record)
        Record = cast<CXXRecordDecl>(
            ND->getDeclContext()->getRedeclContext());
      R.setNamingClass(Record);
    }

    auto *UnderlyingND = ND->getUnderlyingDecl();
    AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
                             isa<FunctionTemplateDecl>(UnderlyingND);
    // FIXME: If we ended up with a typo for a type name or
    // Objective-C class name, we're in trouble because the parser
    // is in the wrong place to recover. Suggest the typo
    // correction, but don't make it a fix-it since we're not going
    // to recover well anyway.
    AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
                                getAsTypeTemplateDecl(UnderlyingND) ||
                                isa<ObjCInterfaceDecl>(UnderlyingND);
  } else {
    // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
    // because we aren't able to recover.
    AcceptableWithoutRecovery = true;
  }

  if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
    unsigned NoteID = Corrected.getCorrectionDeclAs<ImplicitParamDecl>()
                          ? diag::note_implicit_param_decl
                          : diag::note_previous_decl;
    if (SS.isEmpty())
      diagnoseTypo(Corrected, PDiag(diagnostic_suggest) << Name,
                   PDiag(NoteID), AcceptableWithRecovery);
    else
      diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
                                << Name << computeDeclContext(SS, false)
                                << DroppedSpecifier << SS.getRange(),
                   PDiag(NoteID), AcceptableWithRecovery);

    // Tell the callee whether to try to recover.
    return !AcceptableWithRecovery;
  }
}
R.clear();

// Emit a special diagnostic for failed member lookups.
// FIXME: computing the declaration context might fail here (?)
if (!SS.isEmpty()) {
  Diag(R.getNameLoc(), diag::err_no_member)
    << Name << computeDeclContext(SS, false)
    << SS.getRange();
  return true;
}

// Give up, we can't recover.
Diag(R.getNameLoc(), diagnostic) << Name;
return true;
2439}

2441/// In Microsoft mode, if we are inside a template class whose parent class has
2442/// dependent base classes, and we can't resolve an unqualified identifier, then
2443/// assume the identifier is a member of a dependent base class.  We can only
2444/// recover successfully in static methods, instance methods, and other contexts
2445/// where 'this' is available.  This doesn't precisely match MSVC's
2446/// instantiation model, but it's close enough.
2447static Expr *
2448recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
                             DeclarationNameInfo &NameInfo,
                             SourceLocation TemplateKWLoc,
                             const TemplateArgumentListInfo *TemplateArgs) {
// Only try to recover from lookup into dependent bases in static methods or
// contexts where 'this' is available.
QualType ThisType = S.getCurrentThisType();
const CXXRecordDecl *RD = nullptr;
if (!ThisType.isNull())
  RD = ThisType->getPointeeType()->getAsCXXRecordDecl();
else if (auto *MD = dyn_cast<CXXMethodDecl>(S.CurContext))
  RD = MD->getParent();
if (!RD || !RD->hasAnyDependentBases())
  return nullptr;

// Diagnose this as unqualified lookup into a dependent base class.  If 'this'
// is available, suggest inserting 'this->' as a fixit.
SourceLocation Loc = NameInfo.getLoc();
auto DB = S.Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
DB << NameInfo.getName() << RD;

if (!ThisType.isNull()) {
  DB << FixItHint::CreateInsertion(Loc, "this->");
  return CXXDependentScopeMemberExpr::Create(
      Context, /*This=*/nullptr, ThisType, /*IsArrow=*/true,
      /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc,
      /*FirstQualifierFoundInScope=*/nullptr, NameInfo, TemplateArgs);
}

// Synthesize a fake NNS that points to the derived class.  This will
// perform name lookup during template instantiation.
CXXScopeSpec SS;
auto *NNS =
    NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl());
SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc));
return DependentScopeDeclRefExpr::Create(
    Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
    TemplateArgs);
2486}

2488ExprResult
2489Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                      SourceLocation TemplateKWLoc, UnqualifiedId &Id,
                      bool HasTrailingLParen, bool IsAddressOfOperand,
                      CorrectionCandidateCallback *CCC,
                      bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
assert(!(IsAddressOfOperand && HasTrailingLParen) &&(static_cast <bool> (!(IsAddressOfOperand && HasTrailingLParen
) && "cannot be direct & operand and have a trailing lparen"
) ? void (0) : __assert_fail ("!(IsAddressOfOperand && HasTrailingLParen) && \"cannot be direct & operand and have a trailing lparen\""
, "clang/lib/Sema/SemaExpr.cpp", 2495, __extension__ __PRETTY_FUNCTION__
))
       "cannot be direct & operand and have a trailing lparen")(static_cast <bool> (!(IsAddressOfOperand && HasTrailingLParen
) && "cannot be direct & operand and have a trailing lparen"
) ? void (0) : __assert_fail ("!(IsAddressOfOperand && HasTrailingLParen) && \"cannot be direct & operand and have a trailing lparen\""
, "clang/lib/Sema/SemaExpr.cpp", 2495, __extension__ __PRETTY_FUNCTION__
));
if (SS.isInvalid())
  return ExprError();

TemplateArgumentListInfo TemplateArgsBuffer;

// Decompose the UnqualifiedId into the following data.
DeclarationNameInfo NameInfo;
const TemplateArgumentListInfo *TemplateArgs;
DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs);

DeclarationName Name = NameInfo.getName();
IdentifierInfo *II = Name.getAsIdentifierInfo();
SourceLocation NameLoc = NameInfo.getLoc();

if (II && II->isEditorPlaceholder()) {
  // FIXME: When typed placeholders are supported we can create a typed
  // placeholder expression node.
  return ExprError();
}

// C++ [temp.dep.expr]p3:
//   An id-expression is type-dependent if it contains:
//     -- an identifier that was declared with a dependent type,
//        (note: handled after lookup)
//     -- a template-id that is dependent,
//        (note: handled in BuildTemplateIdExpr)
//     -- a conversion-function-id that specifies a dependent type,
//     -- a nested-name-specifier that contains a class-name that
//        names a dependent type.
// Determine whether this is a member of an unknown specialization;
// we need to handle these differently.
bool DependentID = false;
if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
    Name.getCXXNameType()->isDependentType()) {
  DependentID = true;
} else if (SS.isSet()) {
  if (DeclContext *DC = computeDeclContext(SS, false)) {
    if (RequireCompleteDeclContext(SS, DC))
      return ExprError();
  } else {
    DependentID = true;
  }
}

if (DependentID)
  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
                                    IsAddressOfOperand, TemplateArgs);

// Perform the required lookup.
LookupResult R(*this, NameInfo,
               (Id.getKind() == UnqualifiedIdKind::IK_ImplicitSelfParam)
                   ? LookupObjCImplicitSelfParam
                   : LookupOrdinaryName);
if (TemplateKWLoc.isValid() || TemplateArgs) {
  // Lookup the template name again to correctly establish the context in
  // which it was found. This is really unfortunate as we already did the
  // lookup to determine that it was a template name in the first place. If
  // this becomes a performance hit, we can work harder to preserve those
  // results until we get here but it's likely not worth it.
  bool MemberOfUnknownSpecialization;
  AssumedTemplateKind AssumedTemplate;
  if (LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false,
                         MemberOfUnknownSpecialization, TemplateKWLoc,
                         &AssumedTemplate))
    return ExprError();

  if (MemberOfUnknownSpecialization ||
      (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation))
    return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
                                      IsAddressOfOperand, TemplateArgs);
} else {
  bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl();
  LookupParsedName(R, S, &SS, !IvarLookupFollowUp);

  // If the result might be in a dependent base class, this is a dependent
  // id-expression.
  if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)
    return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
                                      IsAddressOfOperand, TemplateArgs);

  // If this reference is in an Objective-C method, then we need to do
  // some special Objective-C lookup, too.
  if (IvarLookupFollowUp) {
    ExprResult E(LookupInObjCMethod(R, S, II, true));
    if (E.isInvalid())
      return ExprError();

    if (Expr *Ex = E.getAs<Expr>())
      return Ex;
  }
}

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

// This could be an implicitly declared function reference if the language
// mode allows it as a feature.
if (R.empty() && HasTrailingLParen && II &&
    getLangOpts().implicitFunctionsAllowed()) {
  NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
  if (D) R.addDecl(D);
}

// Determine whether this name might be a candidate for
// argument-dependent lookup.
bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);

if (R.empty() && !ADL) {
  if (SS.isEmpty() && getLangOpts().MSVCCompat) {
    if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
                                                 TemplateKWLoc, TemplateArgs))
      return E;
  }

  // Don't diagnose an empty lookup for inline assembly.
  if (IsInlineAsmIdentifier)
    return ExprError();

  // If this name wasn't predeclared and if this is not a function
  // call, diagnose the problem.
  TypoExpr *TE = nullptr;
  DefaultFilterCCC DefaultValidator(II, SS.isValid() ? SS.getScopeRep()
                                                     : nullptr);
  DefaultValidator.IsAddressOfOperand = IsAddressOfOperand;
  assert((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) &&(static_cast <bool> ((!CCC || CCC->IsAddressOfOperand
 == IsAddressOfOperand) && "Typo correction callback misconfigured"
) ? void (0) : __assert_fail ("(!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) && \"Typo correction callback misconfigured\""
, "clang/lib/Sema/SemaExpr.cpp", 2621, __extension__ __PRETTY_FUNCTION__
))
         "Typo correction callback misconfigured")(static_cast <bool> ((!CCC || CCC->IsAddressOfOperand
 == IsAddressOfOperand) && "Typo correction callback misconfigured"
) ? void (0) : __assert_fail ("(!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) && \"Typo correction callback misconfigured\""
, "clang/lib/Sema/SemaExpr.cpp", 2621, __extension__ __PRETTY_FUNCTION__
));
  if (CCC) {
    // Make sure the callback knows what the typo being diagnosed is.
    CCC->setTypoName(II);
    if (SS.isValid())
      CCC->setTypoNNS(SS.getScopeRep());
  }
  // FIXME: DiagnoseEmptyLookup produces bad diagnostics if we're looking for
  // a template name, but we happen to have always already looked up the name
  // before we get here if it must be a template name.
  if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator, nullptr,
                          std::nullopt, &TE)) {
    if (TE && KeywordReplacement) {
      auto &State = getTypoExprState(TE);
      auto BestTC = State.Consumer->getNextCorrection();
      if (BestTC.isKeyword()) {
        auto *II = BestTC.getCorrectionAsIdentifierInfo();
        if (State.DiagHandler)
          State.DiagHandler(BestTC);
        KeywordReplacement->startToken();
        KeywordReplacement->setKind(II->getTokenID());
        KeywordReplacement->setIdentifierInfo(II);
        KeywordReplacement->setLocation(BestTC.getCorrectionRange().getBegin());
        // Clean up the state associated with the TypoExpr, since it has
        // now been diagnosed (without a call to CorrectDelayedTyposInExpr).
        clearDelayedTypo(TE);
        // Signal that a correction to a keyword was performed by returning a
        // valid-but-null ExprResult.
        return (Expr*)nullptr;
      }
      State.Consumer->resetCorrectionStream();
    }
    return TE ? TE : ExprError();
  }

  assert(!R.empty() &&(static_cast <bool> (!R.empty() && "DiagnoseEmptyLookup returned false but added no results"
) ? void (0) : __assert_fail ("!R.empty() && \"DiagnoseEmptyLookup returned false but added no results\""
, "clang/lib/Sema/SemaExpr.cpp", 2657, __extension__ __PRETTY_FUNCTION__
))
         "DiagnoseEmptyLookup returned false but added no results")(static_cast <bool> (!R.empty() && "DiagnoseEmptyLookup returned false but added no results"
) ? void (0) : __assert_fail ("!R.empty() && \"DiagnoseEmptyLookup returned false but added no results\""
, "clang/lib/Sema/SemaExpr.cpp", 2657, __extension__ __PRETTY_FUNCTION__
));

  // If we found an Objective-C instance variable, let
  // LookupInObjCMethod build the appropriate expression to
  // reference the ivar.
  if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) {
    R.clear();
    ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier()));
    // In a hopelessly buggy code, Objective-C instance variable
    // lookup fails and no expression will be built to reference it.
    if (!E.isInvalid() && !E.get())
      return ExprError();
    return E;
  }
}

// This is guaranteed from this point on.
assert(!R.empty() || ADL)(static_cast <bool> (!R.empty() || ADL) ? void (0) : __assert_fail
 ("!R.empty() || ADL", "clang/lib/Sema/SemaExpr.cpp", 2674, __extension__
 __PRETTY_FUNCTION__));

// Check whether this might be a C++ implicit instance member access.
// C++ [class.mfct.non-static]p3:
//   When an id-expression that is not part of a class member access
//   syntax and not used to form a pointer to member is used in the
//   body of a non-static member function of class X, if name lookup
//   resolves the name in the id-expression to a non-static non-type
//   member of some class C, the id-expression is transformed into a
//   class member access expression using (*this) as the
//   postfix-expression to the left of the . operator.
//
// But we don't actually need to do this for '&' operands if R
// resolved to a function or overloaded function set, because the
// expression is ill-formed if it actually works out to be a
// non-static member function:
//
// C++ [expr.ref]p4:
//   Otherwise, if E1.E2 refers to a non-static member function. . .
//   [t]he expression can be used only as the left-hand operand of a
//   member function call.
//
// There are other safeguards against such uses, but it's important
// to get this right here so that we don't end up making a
// spuriously dependent expression if we're inside a dependent
// instance method.
if (!R.empty() && (*R.begin())->isCXXClassMember()) {
  bool MightBeImplicitMember;
  if (!IsAddressOfOperand)
    MightBeImplicitMember = true;
  else if (!SS.isEmpty())
    MightBeImplicitMember = false;
  else if (R.isOverloadedResult())
    MightBeImplicitMember = false;
  else if (R.isUnresolvableResult())
    MightBeImplicitMember = true;
  else
    MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) ||
                            isa<IndirectFieldDecl>(R.getFoundDecl()) ||
                            isa<MSPropertyDecl>(R.getFoundDecl());

  if (MightBeImplicitMember)
    return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc,
                                           R, TemplateArgs, S);
}

if (TemplateArgs || TemplateKWLoc.isValid()) {

  // In C++1y, if this is a variable template id, then check it
  // in BuildTemplateIdExpr().
  // The single lookup result must be a variable template declaration.
  if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId && Id.TemplateId &&
      Id.TemplateId->Kind == TNK_Var_template) {
    assert(R.getAsSingle<VarTemplateDecl>() &&(static_cast <bool> (R.getAsSingle<VarTemplateDecl>
() && "There should only be one declaration found.") ?
 void (0) : __assert_fail ("R.getAsSingle<VarTemplateDecl>() && \"There should only be one declaration found.\""
, "clang/lib/Sema/SemaExpr.cpp", 2728, __extension__ __PRETTY_FUNCTION__
))
           "There should only be one declaration found.")(static_cast <bool> (R.getAsSingle<VarTemplateDecl>
() && "There should only be one declaration found.") ?
 void (0) : __assert_fail ("R.getAsSingle<VarTemplateDecl>() && \"There should only be one declaration found.\""
, "clang/lib/Sema/SemaExpr.cpp", 2728, __extension__ __PRETTY_FUNCTION__
));
  }

  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
}

return BuildDeclarationNameExpr(SS, R, ADL);
2735}

2737/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
2738/// declaration name, generally during template instantiation.
2739/// There's a large number of things which don't need to be done along
2740/// this path.
2741ExprResult Sema::BuildQualifiedDeclarationNameExpr(
  CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo,
  bool IsAddressOfOperand, const Scope *S, TypeSourceInfo **RecoveryTSI) {
if (NameInfo.getName().isDependentName())
  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
                                   NameInfo, /*TemplateArgs=*/nullptr);

DeclContext *DC = computeDeclContext(SS, false);
if (!DC)
  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
                                   NameInfo, /*TemplateArgs=*/nullptr);

if (RequireCompleteDeclContext(SS, DC))
  return ExprError();

LookupResult R(*this, NameInfo, LookupOrdinaryName);
LookupQualifiedName(R, DC);

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

if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)
  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
                                   NameInfo, /*TemplateArgs=*/nullptr);

if (R.empty()) {
  // Don't diagnose problems with invalid record decl, the secondary no_member
  // diagnostic during template instantiation is likely bogus, e.g. if a class
  // is invalid because it's derived from an invalid base class, then missing
  // members were likely supposed to be inherited.
  if (const auto *CD = dyn_cast<CXXRecordDecl>(DC))
    if (CD->isInvalidDecl())
      return ExprError();
  Diag(NameInfo.getLoc(), diag::err_no_member)
    << NameInfo.getName() << DC << SS.getRange();
  return ExprError();
}

if (const TypeDecl *TD = R.getAsSingle<TypeDecl>()) {
  // Diagnose a missing typename if this resolved unambiguously to a type in
  // a dependent context.  If we can recover with a type, downgrade this to
  // a warning in Microsoft compatibility mode.
  unsigned DiagID = diag::err_typename_missing;
  if (RecoveryTSI && getLangOpts().MSVCCompat)
    DiagID = diag::ext_typename_missing;
  SourceLocation Loc = SS.getBeginLoc();
  auto D = Diag(Loc, DiagID);
  D << SS.getScopeRep() << NameInfo.getName().getAsString()
    << SourceRange(Loc, NameInfo.getEndLoc());

  // Don't recover if the caller isn't expecting us to or if we're in a SFINAE
  // context.
  if (!RecoveryTSI)
    return ExprError();

  // Only issue the fixit if we're prepared to recover.
  D << FixItHint::CreateInsertion(Loc, "typename ");

  // Recover by pretending this was an elaborated type.
  QualType Ty = Context.getTypeDeclType(TD);
  TypeLocBuilder TLB;
  TLB.pushTypeSpec(Ty).setNameLoc(NameInfo.getLoc());

  QualType ET = getElaboratedType(ETK_None, SS, Ty);
  ElaboratedTypeLoc QTL = TLB.push<ElaboratedTypeLoc>(ET);
  QTL.setElaboratedKeywordLoc(SourceLocation());
  QTL.setQualifierLoc(SS.getWithLocInContext(Context));

  *RecoveryTSI = TLB.getTypeSourceInfo(Context, ET);

  return ExprEmpty();
}

// Defend against this resolving to an implicit member access. We usually
// won't get here if this might be a legitimate a class member (we end up in
// BuildMemberReferenceExpr instead), but this can be valid if we're forming
// a pointer-to-member or in an unevaluated context in C++11.
if (!R.empty() && (*R.begin())->isCXXClassMember() && !IsAddressOfOperand)
  return BuildPossibleImplicitMemberExpr(SS,
                                         /*TemplateKWLoc=*/SourceLocation(),
                                         R, /*TemplateArgs=*/nullptr, S);

return BuildDeclarationNameExpr(SS, R, /* ADL */ false);
2824}

2826/// The parser has read a name in, and Sema has detected that we're currently
2827/// inside an ObjC method. Perform some additional checks and determine if we
2828/// should form a reference to an ivar.
2829///
2830/// Ideally, most of this would be done by lookup, but there's
2831/// actually quite a lot of extra work involved.
2832DeclResult Sema::LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,
                                      IdentifierInfo *II) {
SourceLocation Loc = Lookup.getNameLoc();
ObjCMethodDecl *CurMethod = getCurMethodDecl();

// Check for error condition which is already reported.
if (!CurMethod)
  return DeclResult(true);

// There are two cases to handle here.  1) scoped lookup could have failed,
// in which case we should look for an ivar.  2) scoped lookup could have
// found a decl, but that decl is outside the current instance method (i.e.
// a global variable).  In these two cases, we do a lookup for an ivar with
// this name, if the lookup sucedes, we replace it our current decl.

// If we're in a class method, we don't normally want to look for
// ivars.  But if we don't find anything else, and there's an
// ivar, that's an error.
bool IsClassMethod = CurMethod->isClassMethod();

bool LookForIvars;
if (Lookup.empty())
  LookForIvars = true;
else if (IsClassMethod)
  LookForIvars = false;
else
  LookForIvars = (Lookup.isSingleResult() &&
                  Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod());
ObjCInterfaceDecl *IFace = nullptr;
if (LookForIvars) {
  IFace = CurMethod->getClassInterface();
  ObjCInterfaceDecl *ClassDeclared;
  ObjCIvarDecl *IV = nullptr;
  if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) {
    // Diagnose using an ivar in a class method.
    if (IsClassMethod) {
      Diag(Loc, diag::err_ivar_use_in_class_method) << IV->getDeclName();
      return DeclResult(true);
    }

    // Diagnose the use of an ivar outside of the declaring class.
    if (IV->getAccessControl() == ObjCIvarDecl::Private &&
        !declaresSameEntity(ClassDeclared, IFace) &&
        !getLangOpts().DebuggerSupport)
      Diag(Loc, diag::err_private_ivar_access) << IV->getDeclName();

    // Success.
    return IV;
  }
} else if (CurMethod->isInstanceMethod()) {
  // We should warn if a local variable hides an ivar.
  if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) {
    ObjCInterfaceDecl *ClassDeclared;
    if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
      if (IV->getAccessControl() != ObjCIvarDecl::Private ||
          declaresSameEntity(IFace, ClassDeclared))
        Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
    }
  }
} else if (Lookup.isSingleResult() &&
           Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) {
  // If accessing a stand-alone ivar in a class method, this is an error.
  if (const ObjCIvarDecl *IV =
          dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) {
    Diag(Loc, diag::err_ivar_use_in_class_method) << IV->getDeclName();
    return DeclResult(true);
  }
}

// Didn't encounter an error, didn't find an ivar.
return DeclResult(false);
2903}

2905ExprResult Sema::BuildIvarRefExpr(Scope *S, SourceLocation Loc,
                                ObjCIvarDecl *IV) {
ObjCMethodDecl *CurMethod = getCurMethodDecl();
assert(CurMethod && CurMethod->isInstanceMethod() &&(static_cast <bool> (CurMethod && CurMethod->
isInstanceMethod() && "should not reference ivar from this context"
) ? void (0) : __assert_fail ("CurMethod && CurMethod->isInstanceMethod() && \"should not reference ivar from this context\""
, "clang/lib/Sema/SemaExpr.cpp", 2909, __extension__ __PRETTY_FUNCTION__
))
       "should not reference ivar from this context")(static_cast <bool> (CurMethod && CurMethod->
isInstanceMethod() && "should not reference ivar from this context"
) ? void (0) : __assert_fail ("CurMethod && CurMethod->isInstanceMethod() && \"should not reference ivar from this context\""
, "clang/lib/Sema/SemaExpr.cpp", 2909, __extension__ __PRETTY_FUNCTION__
));

ObjCInterfaceDecl *IFace = CurMethod->getClassInterface();
assert(IFace && "should not reference ivar from this context")(static_cast <bool> (IFace && "should not reference ivar from this context"
) ? void (0) : __assert_fail ("IFace && \"should not reference ivar from this context\""
, "clang/lib/Sema/SemaExpr.cpp", 2912, __extension__ __PRETTY_FUNCTION__
));

// If we're referencing an invalid decl, just return this as a silent
// error node.  The error diagnostic was already emitted on the decl.
if (IV->isInvalidDecl())
  return ExprError();

// Check if referencing a field with __attribute__((deprecated)).
if (DiagnoseUseOfDecl(IV, Loc))
  return ExprError();

// FIXME: This should use a new expr for a direct reference, don't
// turn this into Self->ivar, just return a BareIVarExpr or something.
IdentifierInfo &II = Context.Idents.get("self");
UnqualifiedId SelfName;
SelfName.setImplicitSelfParam(&II);
CXXScopeSpec SelfScopeSpec;
SourceLocation TemplateKWLoc;
ExprResult SelfExpr =
    ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, SelfName,
                      /*HasTrailingLParen=*/false,
                      /*IsAddressOfOperand=*/false);
if (SelfExpr.isInvalid())
  return ExprError();

SelfExpr = DefaultLvalueConversion(SelfExpr.get());
if (SelfExpr.isInvalid())
  return ExprError();

MarkAnyDeclReferenced(Loc, IV, true);

ObjCMethodFamily MF = CurMethod->getMethodFamily();
if (MF != OMF_init && MF != OMF_dealloc && MF != OMF_finalize &&
    !IvarBacksCurrentMethodAccessor(IFace, CurMethod, IV))
  Diag(Loc, diag::warn_direct_ivar_access) << IV->getDeclName();

ObjCIvarRefExpr *Result = new (Context)
    ObjCIvarRefExpr(IV, IV->getUsageType(SelfExpr.get()->getType()), Loc,
                    IV->getLocation(), SelfExpr.get(), true, true);

if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
  if (!isUnevaluatedContext() &&
      !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))
    getCurFunction()->recordUseOfWeak(Result);
}
if (getLangOpts().ObjCAutoRefCount && !isUnevaluatedContext())
  if (const BlockDecl *BD = CurContext->getInnermostBlockDecl())
    ImplicitlyRetainedSelfLocs.push_back({Loc, BD});

return Result;
2962}

2964/// The parser has read a name in, and Sema has detected that we're currently
2965/// inside an ObjC method. Perform some additional checks and determine if we
2966/// should form a reference to an ivar. If so, build an expression referencing
2967/// that ivar.
2968ExprResult
2969Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S,
                       IdentifierInfo *II, bool AllowBuiltinCreation) {
// FIXME: Integrate this lookup step into LookupParsedName.
DeclResult Ivar = LookupIvarInObjCMethod(Lookup, S, II);
if (Ivar.isInvalid())
  return ExprError();
if (Ivar.isUsable())
  return BuildIvarRefExpr(S, Lookup.getNameLoc(),
                          cast<ObjCIvarDecl>(Ivar.get()));

if (Lookup.empty() && II && AllowBuiltinCreation)
  LookupBuiltin(Lookup);

// Sentinel value saying that we didn't do anything special.
return ExprResult(false);
2984}

2986/// Cast a base object to a member's actual type.
2987///
2988/// There are two relevant checks:
2989///
2990/// C++ [class.access.base]p7:
2991///
2992///   If a class member access operator [...] is used to access a non-static
2993///   data member or non-static member function, the reference is ill-formed if
2994///   the left operand [...] cannot be implicitly converted to a pointer to the
2995///   naming class of the right operand.
2996///
2997/// C++ [expr.ref]p7:
2998///
2999///   If E2 is a non-static data member or a non-static member function, the
3000///   program is ill-formed if the class of which E2 is directly a member is an
3001///   ambiguous base (11.8) of the naming class (11.9.3) of E2.
3002///
3003/// Note that the latter check does not consider access; the access of the
3004/// "real" base class is checked as appropriate when checking the access of the
3005/// member name.
3006ExprResult
3007Sema::PerformObjectMemberConversion(Expr *From,
                                  NestedNameSpecifier *Qualifier,
                                  NamedDecl *FoundDecl,
                                  NamedDecl *Member) {
const auto *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext());
if (!RD)
  return From;

QualType DestRecordType;
QualType DestType;
QualType FromRecordType;
QualType FromType = From->getType();
bool PointerConversions = false;
if (isa<FieldDecl>(Member)) {
  DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD));
  auto FromPtrType = FromType->getAs<PointerType>();
  DestRecordType = Context.getAddrSpaceQualType(
      DestRecordType, FromPtrType
                          ? FromType->getPointeeType().getAddressSpace()
                          : FromType.getAddressSpace());

  if (FromPtrType) {
    DestType = Context.getPointerType(DestRecordType);
    FromRecordType = FromPtrType->getPointeeType();
    PointerConversions = true;
  } else {
    DestType = DestRecordType;
    FromRecordType = FromType;
  }
} else if (const auto *Method = dyn_cast<CXXMethodDecl>(Member)) {
  if (Method->isStatic())
    return From;

  DestType = Method->getThisType();
  DestRecordType = DestType->getPointeeType();

  if (FromType->getAs<PointerType>()) {
    FromRecordType = FromType->getPointeeType();
    PointerConversions = true;
  } else {
    FromRecordType = FromType;
    DestType = DestRecordType;
  }

  LangAS FromAS = FromRecordType.getAddressSpace();
  LangAS DestAS = DestRecordType.getAddressSpace();
  if (FromAS != DestAS) {
    QualType FromRecordTypeWithoutAS =
        Context.removeAddrSpaceQualType(FromRecordType);
    QualType FromTypeWithDestAS =
        Context.getAddrSpaceQualType(FromRecordTypeWithoutAS, DestAS);
    if (PointerConversions)
      FromTypeWithDestAS = Context.getPointerType(FromTypeWithDestAS);
    From = ImpCastExprToType(From, FromTypeWithDestAS,
                             CK_AddressSpaceConversion, From->getValueKind())
               .get();
  }
} else {
  // No conversion necessary.
  return From;
}

if (DestType->isDependentType() || FromType->isDependentType())
  return From;

// If the unqualified types are the same, no conversion is necessary.
if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
  return From;

SourceRange FromRange = From->getSourceRange();
SourceLocation FromLoc = FromRange.getBegin();

ExprValueKind VK = From->getValueKind();

// C++ [class.member.lookup]p8:
//   [...] Ambiguities can often be resolved by qualifying a name with its
//   class name.
//
// If the member was a qualified name and the qualified referred to a
// specific base subobject type, we'll cast to that intermediate type
// first and then to the object in which the member is declared. That allows
// one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as:
//
//   class Base { public: int x; };
//   class Derived1 : public Base { };
//   class Derived2 : public Base { };
//   class VeryDerived : public Derived1, public Derived2 { void f(); };
//
//   void VeryDerived::f() {
//     x = 17; // error: ambiguous base subobjects
//     Derived1::x = 17; // okay, pick the Base subobject of Derived1
//   }
if (Qualifier && Qualifier->getAsType()) {
  QualType QType = QualType(Qualifier->getAsType(), 0);
  assert(QType->isRecordType() && "lookup done with non-record type")(static_cast <bool> (QType->isRecordType() &&
 "lookup done with non-record type") ? void (0) : __assert_fail
 ("QType->isRecordType() && \"lookup done with non-record type\""
, "clang/lib/Sema/SemaExpr.cpp", 3101, __extension__ __PRETTY_FUNCTION__
));

  QualType QRecordType = QualType(QType->castAs<RecordType>(), 0);

  // In C++98, the qualifier type doesn't actually have to be a base
  // type of the object type, in which case we just ignore it.
  // Otherwise build the appropriate casts.
  if (IsDerivedFrom(FromLoc, FromRecordType, QRecordType)) {
    CXXCastPath BasePath;
    if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
                                     FromLoc, FromRange, &BasePath))
      return ExprError();

    if (PointerConversions)
      QType = Context.getPointerType(QType);
    From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
                             VK, &BasePath).get();

    FromType = QType;
    FromRecordType = QRecordType;

    // If the qualifier type was the same as the destination type,
    // we're done.
    if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
      return From;
  }
}

CXXCastPath BasePath;
if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
                                 FromLoc, FromRange, &BasePath,
                                 /*IgnoreAccess=*/true))
  return ExprError();

return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase,
                         VK, &BasePath);
3137}

3139bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
                                    const LookupResult &R,
                                    bool HasTrailingLParen) {
// Only when used directly as the postfix-expression of a call.
if (!HasTrailingLParen)
  return false;

// Never if a scope specifier was provided.
if (SS.isSet())
  return false;

// Only in C++ or ObjC++.
if (!getLangOpts().CPlusPlus)
  return false;

// Turn off ADL when we find certain kinds of declarations during
// normal lookup:
for (const NamedDecl *D : R) {
  // C++0x [basic.lookup.argdep]p3:
  //     -- a declaration of a class member
  // Since using decls preserve this property, we check this on the
  // original decl.
  if (D->isCXXClassMember())
    return false;

  // C++0x [basic.lookup.argdep]p3:
  //     -- a block-scope function declaration that is not a
  //        using-declaration
  // NOTE: we also trigger this for function templates (in fact, we
  // don't check the decl type at all, since all other decl types
  // turn off ADL anyway).
  if (isa<UsingShadowDecl>(D))
    D = cast<UsingShadowDecl>(D)->getTargetDecl();
  else if (D->getLexicalDeclContext()->isFunctionOrMethod())
    return false;

  // C++0x [basic.lookup.argdep]p3:
  //     -- a declaration that is neither a function or a function
  //        template
  // And also for builtin functions.
  if (const auto *FDecl = dyn_cast<FunctionDecl>(D)) {
    // But also builtin functions.
    if (FDecl->getBuiltinID() && FDecl->isImplicit())
      return false;
  } else if (!isa<FunctionTemplateDecl>(D))
    return false;
}

return true;
3188}


3191/// Diagnoses obvious problems with the use of the given declaration
3192/// as an expression.  This is only actually called for lookups that
3193/// were not overloaded, and it doesn't promise that the declaration
3194/// will in fact be used.
3195static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D,
                          bool AcceptInvalid) {
if (D->isInvalidDecl() && !AcceptInvalid)
  return true;

if (isa<TypedefNameDecl>(D)) {
  S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName();
  return true;
}

if (isa<ObjCInterfaceDecl>(D)) {
  S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName();
  return true;
}

if (isa<NamespaceDecl>(D)) {
  S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName();
  return true;
}

return false;
3216}

3218// Certain multiversion types should be treated as overloaded even when there is
3219// only one result.
3220static bool ShouldLookupResultBeMultiVersionOverload(const LookupResult &R) {
assert(R.isSingleResult() && "Expected only a single result")(static_cast <bool> (R.isSingleResult() && "Expected only a single result"
) ? void (0) : __assert_fail ("R.isSingleResult() && \"Expected only a single result\""
, "clang/lib/Sema/SemaExpr.cpp", 3221, __extension__ __PRETTY_FUNCTION__
));
const auto *FD = dyn_cast<FunctionDecl>(R.getFoundDecl());
return FD &&
       (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3225}

3227ExprResult Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                        LookupResult &R, bool NeedsADL,
                                        bool AcceptInvalidDecl) {
// If this is a single, fully-resolved result and we don't need ADL,
// just build an ordinary singleton decl ref.
if (!NeedsADL && R.isSingleResult() &&
    !R.getAsSingle<FunctionTemplateDecl>() &&
    !ShouldLookupResultBeMultiVersionOverload(R))
  return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(),
                                  R.getRepresentativeDecl(), nullptr,
                                  AcceptInvalidDecl);

// We only need to check the declaration if there's exactly one
// result, because in the overloaded case the results can only be
// functions and function templates.
if (R.isSingleResult() && !ShouldLookupResultBeMultiVersionOverload(R) &&
    CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl(),
                    AcceptInvalidDecl))
  return ExprError();

// Otherwise, just build an unresolved lookup expression.  Suppress
// any lookup-related diagnostics; we'll hash these out later, when
// we've picked a target.
R.suppressDiagnostics();

UnresolvedLookupExpr *ULE
  = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
                                 SS.getWithLocInContext(Context),
                                 R.getLookupNameInfo(),
                                 NeedsADL, R.isOverloadedResult(),
                                 R.begin(), R.end());

return ULE;
3260}

3262static void diagnoseUncapturableValueReferenceOrBinding(Sema &S,
                                                      SourceLocation loc,
                                                      ValueDecl *var);

3266/// Complete semantic analysis for a reference to the given declaration.
3267ExprResult Sema::BuildDeclarationNameExpr(
  const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
  NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs,
  bool AcceptInvalidDecl) {
assert(D && "Cannot refer to a NULL declaration")(static_cast <bool> (D && "Cannot refer to a NULL declaration"
) ? void (0) : __assert_fail ("D && \"Cannot refer to a NULL declaration\""
, "clang/lib/Sema/SemaExpr.cpp", 3271, __extension__ __PRETTY_FUNCTION__
));
assert(!isa<FunctionTemplateDecl>(D) &&(static_cast <bool> (!isa<FunctionTemplateDecl>(D
) && "Cannot refer unambiguously to a function template"
) ? void (0) : __assert_fail ("!isa<FunctionTemplateDecl>(D) && \"Cannot refer unambiguously to a function template\""
, "clang/lib/Sema/SemaExpr.cpp", 3273, __extension__ __PRETTY_FUNCTION__
))
       "Cannot refer unambiguously to a function template")(static_cast <bool> (!isa<FunctionTemplateDecl>(D
) && "Cannot refer unambiguously to a function template"
) ? void (0) : __assert_fail ("!isa<FunctionTemplateDecl>(D) && \"Cannot refer unambiguously to a function template\""
, "clang/lib/Sema/SemaExpr.cpp", 3273, __extension__ __PRETTY_FUNCTION__
));

SourceLocation Loc = NameInfo.getLoc();
if (CheckDeclInExpr(*this, Loc, D, AcceptInvalidDecl)) {
  // Recovery from invalid cases (e.g. D is an invalid Decl).
  // We use the dependent type for the RecoveryExpr to prevent bogus follow-up
  // diagnostics, as invalid decls use int as a fallback type.
  return CreateRecoveryExpr(NameInfo.getBeginLoc(), NameInfo.getEndLoc(), {});
}

if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
  // Specifically diagnose references to class templates that are missing
  // a template argument list.
  diagnoseMissingTemplateArguments(TemplateName(Template), Loc);
  return ExprError();
}

// Make sure that we're referring to a value.
if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {
  Diag(Loc, diag::err_ref_non_value) << D << SS.getRange();
  Diag(D->getLocation(), diag::note_declared_at);
  return ExprError();
}

// Check whether this declaration can be used. Note that we suppress
// this check when we're going to perform argument-dependent lookup
// on this function name, because this might not be the function
// that overload resolution actually selects.
if (DiagnoseUseOfDecl(D, Loc))
  return ExprError();

auto *VD = cast<ValueDecl>(D);

// Only create DeclRefExpr's for valid Decl's.
if (VD->isInvalidDecl() && !AcceptInvalidDecl)
  return ExprError();

// Handle members of anonymous structs and unions.  If we got here,
// and the reference is to a class member indirect field, then this
// must be the subject of a pointer-to-member expression.
if (auto *IndirectField = dyn_cast<IndirectFieldDecl>(VD);
    IndirectField && !IndirectField->isCXXClassMember())
  return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(),
                                                  IndirectField);

QualType type = VD->getType();
if (type.isNull())
  return ExprError();
ExprValueKind valueKind = VK_PRValue;

// In 'T ...V;', the type of the declaration 'V' is 'T...', but the type of
// a reference to 'V' is simply (unexpanded) 'T'. The type, like the value,
// is expanded by some outer '...' in the context of the use.
type = type.getNonPackExpansionType();

switch (D->getKind()) {
  // Ignore all the non-ValueDecl kinds.
3330#define ABSTRACT_DECL(kind)
3331#define VALUE(type, base)
3332#define DECL(type, base) case Decl::type:
3333#include "clang/AST/DeclNodes.inc"
  llvm_unreachable("invalid value decl kind")::llvm::llvm_unreachable_internal("invalid value decl kind", "clang/lib/Sema/SemaExpr.cpp"
, 3334);

// These shouldn't make it here.
case Decl::ObjCAtDefsField:
  llvm_unreachable("forming non-member reference to ivar?")::llvm::llvm_unreachable_internal("forming non-member reference to ivar?"
, "clang/lib/Sema/SemaExpr.cpp", 3338);

// Enum constants are always r-values and never references.
// Unresolved using declarations are dependent.
case Decl::EnumConstant:
case Decl::UnresolvedUsingValue:
case Decl::OMPDeclareReduction:
case Decl::OMPDeclareMapper:
  valueKind = VK_PRValue;
  break;

// Fields and indirect fields that got here must be for
// pointer-to-member expressions; we just call them l-values for
// internal consistency, because this subexpression doesn't really
// exist in the high-level semantics.
case Decl::Field:
case Decl::IndirectField:
case Decl::ObjCIvar:
  assert(getLangOpts().CPlusPlus && "building reference to field in C?")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "building reference to field in C?") ? void (0) : __assert_fail
 ("getLangOpts().CPlusPlus && \"building reference to field in C?\""
, "clang/lib/Sema/SemaExpr.cpp", 3356, __extension__ __PRETTY_FUNCTION__
));

  // These can't have reference type in well-formed programs, but
  // for internal consistency we do this anyway.
  type = type.getNonReferenceType();
  valueKind = VK_LValue;
  break;

// Non-type template parameters are either l-values or r-values
// depending on the type.
case Decl::NonTypeTemplateParm: {
  if (const ReferenceType *reftype = type->getAs<ReferenceType>()) {
    type = reftype->getPointeeType();
    valueKind = VK_LValue; // even if the parameter is an r-value reference
    break;
  }

  // [expr.prim.id.unqual]p2:
  //   If the entity is a template parameter object for a template
  //   parameter of type T, the type of the expression is const T.
  //   [...] The expression is an lvalue if the entity is a [...] template
  //   parameter object.
  if (type->isRecordType()) {
    type = type.getUnqualifiedType().withConst();
    valueKind = VK_LValue;
    break;
  }

  // For non-references, we need to strip qualifiers just in case
  // the template parameter was declared as 'const int' or whatever.
  valueKind = VK_PRValue;
  type = type.getUnqualifiedType();
  break;
}

case Decl::Var:
case Decl::VarTemplateSpecialization:
case Decl::VarTemplatePartialSpecialization:
case Decl::Decomposition:
case Decl::OMPCapturedExpr:
  // In C, "extern void blah;" is valid and is an r-value.
  if (!getLangOpts().CPlusPlus && !type.hasQualifiers() &&
      type->isVoidType()) {
    valueKind = VK_PRValue;
    break;
  }
  [[fallthrough]];

case Decl::ImplicitParam:
case Decl::ParmVar: {
  // These are always l-values.
  valueKind = VK_LValue;
  type = type.getNonReferenceType();

  // FIXME: Does the addition of const really only apply in
  // potentially-evaluated contexts? Since the variable isn't actually
  // captured in an unevaluated context, it seems that the answer is no.
  if (!isUnevaluatedContext()) {
    QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc);
    if (!CapturedType.isNull())
      type = CapturedType;
  }

  break;
}

case Decl::Binding:
  // These are always lvalues.
  valueKind = VK_LValue;
  type = type.getNonReferenceType();
  break;

case Decl::Function: {
  if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
    if (!Context.BuiltinInfo.isDirectlyAddressable(BID)) {
      type = Context.BuiltinFnTy;
      valueKind = VK_PRValue;
      break;
    }
  }

  const FunctionType *fty = type->castAs<FunctionType>();

  // If we're referring to a function with an __unknown_anytype
  // result type, make the entire expression __unknown_anytype.
  if (fty->getReturnType() == Context.UnknownAnyTy) {
    type = Context.UnknownAnyTy;
    valueKind = VK_PRValue;
    break;
  }

  // Functions are l-values in C++.
  if (getLangOpts().CPlusPlus) {
    valueKind = VK_LValue;
    break;
  }

  // C99 DR 316 says that, if a function type comes from a
  // function definition (without a prototype), that type is only
  // used for checking compatibility. Therefore, when referencing
  // the function, we pretend that we don't have the full function
  // type.
  if (!cast<FunctionDecl>(VD)->hasPrototype() && isa<FunctionProtoType>(fty))
    type = Context.getFunctionNoProtoType(fty->getReturnType(),
                                          fty->getExtInfo());

  // Functions are r-values in C.
  valueKind = VK_PRValue;
  break;
}

case Decl::CXXDeductionGuide:
  llvm_unreachable("building reference to deduction guide")::llvm::llvm_unreachable_internal("building reference to deduction guide"
, "clang/lib/Sema/SemaExpr.cpp", 3468);

case Decl::MSProperty:
case Decl::MSGuid:
case Decl::TemplateParamObject:
  // FIXME: Should MSGuidDecl and template parameter objects be subject to
  // capture in OpenMP, or duplicated between host and device?
  valueKind = VK_LValue;
  break;

case Decl::UnnamedGlobalConstant:
  valueKind = VK_LValue;
  break;

case Decl::CXXMethod:
  // If we're referring to a method with an __unknown_anytype
  // result type, make the entire expression __unknown_anytype.
  // This should only be possible with a type written directly.
  if (const FunctionProtoType *proto =
          dyn_cast<FunctionProtoType>(VD->getType()))
    if (proto->getReturnType() == Context.UnknownAnyTy) {
      type = Context.UnknownAnyTy;
      valueKind = VK_PRValue;
      break;
    }

  // C++ methods are l-values if static, r-values if non-static.
  if (cast<CXXMethodDecl>(VD)->isStatic()) {
    valueKind = VK_LValue;
    break;
  }
  [[fallthrough]];

case Decl::CXXConversion:
case Decl::CXXDestructor:
case Decl::CXXConstructor:
  valueKind = VK_PRValue;
  break;
}

auto *E =
    BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
                     /*FIXME: TemplateKWLoc*/ SourceLocation(), TemplateArgs);
// Clang AST consumers assume a DeclRefExpr refers to a valid decl. We
// wrap a DeclRefExpr referring to an invalid decl with a dependent-type
// RecoveryExpr to avoid follow-up semantic analysis (thus prevent bogus
// diagnostics).
if (VD->isInvalidDecl() && E)
  return CreateRecoveryExpr(E->getBeginLoc(), E->getEndLoc(), {E});
return E;
3518}

3520static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
                                  SmallString<32> &Target) {
Target.resize(CharByteWidth * (Source.size() + 1));
char *ResultPtr = &Target[0];
const llvm::UTF8 *ErrorPtr;
bool success =
    llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
(void)success;
assert(success)(static_cast <bool> (success) ? void (0) : __assert_fail
 ("success", "clang/lib/Sema/SemaExpr.cpp", 3528, __extension__
 __PRETTY_FUNCTION__));
Target.resize(ResultPtr - &Target[0]);
3530}

3532ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
                                   PredefinedExpr::IdentKind IK) {
// Pick the current block, lambda, captured statement or function.
Decl *currentDecl = nullptr;
if (const BlockScopeInfo *BSI = getCurBlock())
  currentDecl = BSI->TheDecl;
else if (const LambdaScopeInfo *LSI = getCurLambda())
  currentDecl = LSI->CallOperator;
else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
  currentDecl = CSI->TheCapturedDecl;
else
  currentDecl = getCurFunctionOrMethodDecl();

if (!currentDecl) {
  Diag(Loc, diag::ext_predef_outside_function);
  currentDecl = Context.getTranslationUnitDecl();
}

QualType ResTy;
StringLiteral *SL = nullptr;
if (cast<DeclContext>(currentDecl)->isDependentContext())
  ResTy = Context.DependentTy;
else {
  // Pre-defined identifiers are of type char[x], where x is the length of
  // the string.
  auto Str = PredefinedExpr::ComputeName(IK, currentDecl);
  unsigned Length = Str.length();

  llvm::APInt LengthI(32, Length + 1);
  if (IK == PredefinedExpr::LFunction || IK == PredefinedExpr::LFuncSig) {
    ResTy =
        Context.adjustStringLiteralBaseType(Context.WideCharTy.withConst());
    SmallString<32> RawChars;
    ConvertUTF8ToWideString(Context.getTypeSizeInChars(ResTy).getQuantity(),
                            Str, RawChars);
    ResTy = Context.getConstantArrayType(ResTy, LengthI, nullptr,
                                         ArrayType::Normal,
                                         /*IndexTypeQuals*/ 0);
    SL = StringLiteral::Create(Context, RawChars, StringLiteral::Wide,
                               /*Pascal*/ false, ResTy, Loc);
  } else {
    ResTy = Context.adjustStringLiteralBaseType(Context.CharTy.withConst());
    ResTy = Context.getConstantArrayType(ResTy, LengthI, nullptr,
                                         ArrayType::Normal,
                                         /*IndexTypeQuals*/ 0);
    SL = StringLiteral::Create(Context, Str, StringLiteral::Ordinary,
                               /*Pascal*/ false, ResTy, Loc);
  }
}

return PredefinedExpr::Create(Context, Loc, ResTy, IK, SL);
3583}

3585ExprResult Sema::BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                             SourceLocation LParen,
                                             SourceLocation RParen,
                                             TypeSourceInfo *TSI) {
return SYCLUniqueStableNameExpr::Create(Context, OpLoc, LParen, RParen, TSI);
3590}

3592ExprResult Sema::ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                             SourceLocation LParen,
                                             SourceLocation RParen,
                                             ParsedType ParsedTy) {
TypeSourceInfo *TSI = nullptr;
QualType Ty = GetTypeFromParser(ParsedTy, &TSI);

if (Ty.isNull())
  return ExprError();
if (!TSI)
  TSI = Context.getTrivialTypeSourceInfo(Ty, LParen);

return BuildSYCLUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
3605}

3607ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) {
PredefinedExpr::IdentKind IK;

switch (Kind) {
default: llvm_unreachable("Unknown simple primary expr!")::llvm::llvm_unreachable_internal("Unknown simple primary expr!"
, "clang/lib/Sema/SemaExpr.cpp", 3611);
case tok::kw___func__: IK = PredefinedExpr::Func; break; // [C99 6.4.2.2]
case tok::kw___FUNCTION__: IK = PredefinedExpr::Function; break;
case tok::kw___FUNCDNAME__: IK = PredefinedExpr::FuncDName; break; // [MS]
case tok::kw___FUNCSIG__: IK = PredefinedExpr::FuncSig; break; // [MS]
case tok::kw_L__FUNCTION__: IK = PredefinedExpr::LFunction; break; // [MS]
case tok::kw_L__FUNCSIG__: IK = PredefinedExpr::LFuncSig; break; // [MS]
case tok::kw___PRETTY_FUNCTION__: IK = PredefinedExpr::PrettyFunction; break;
}

return BuildPredefinedExpr(Loc, IK);
3622}

3624ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
SmallString<16> CharBuffer;
bool Invalid = false;
StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
if (Invalid)
  return ExprError();

CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(),
                          PP, Tok.getKind());
if (Literal.hadError())
  return ExprError();

QualType Ty;
if (Literal.isWide())
  Ty = Context.WideCharTy; // L'x' -> wchar_t in C and C++.
else if (Literal.isUTF8() && getLangOpts().C2x)
  Ty = Context.UnsignedCharTy; // u8'x' -> unsigned char in C2x
else if (Literal.isUTF8() && getLangOpts().Char8)
  Ty = Context.Char8Ty; // u8'x' -> char8_t when it exists.
else if (Literal.isUTF16())
  Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11.
else if (Literal.isUTF32())
  Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11.
else if (!getLangOpts().CPlusPlus || Literal.isMultiChar())
  Ty = Context.IntTy;   // 'x' -> int in C, 'wxyz' -> int in C++.
else
  Ty = Context.CharTy; // 'x' -> char in C++;
                       // u8'x' -> char in C11-C17 and in C++ without char8_t.

CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii;
if (Literal.isWide())
  Kind = CharacterLiteral::Wide;
else if (Literal.isUTF16())
  Kind = CharacterLiteral::UTF16;
else if (Literal.isUTF32())
  Kind = CharacterLiteral::UTF32;
else if (Literal.isUTF8())
  Kind = CharacterLiteral::UTF8;

Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
                                           Tok.getLocation());

if (Literal.getUDSuffix().empty())
  return Lit;

// We're building a user-defined literal.
IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
  getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());

// Make sure we're allowed user-defined literals here.
if (!UDLScope)
  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl));

// C++11 [lex.ext]p6: The literal L is treated as a call of the form
//   operator "" X (ch)
return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc,
                                      Lit, Tok.getLocation());
3682}

3684ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) {
unsigned IntSize = Context.getTargetInfo().getIntWidth();
return IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val),
                              Context.IntTy, Loc);
3688}

3690static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal,
                                QualType Ty, SourceLocation Loc) {
const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty);

using llvm::APFloat;
APFloat Val(Format);

APFloat::opStatus result = Literal.GetFloatValue(Val);

// Overflow is always an error, but underflow is only an error if
// we underflowed to zero (APFloat reports denormals as underflow).
if ((result & APFloat::opOverflow) ||
    ((result & APFloat::opUnderflow) && Val.isZero())) {
  unsigned diagnostic;
  SmallString<20> buffer;
  if (result & APFloat::opOverflow) {
    diagnostic = diag::warn_float_overflow;
    APFloat::getLargest(Format).toString(buffer);
  } else {
    diagnostic = diag::warn_float_underflow;
    APFloat::getSmallest(Format).toString(buffer);
  }

  S.Diag(Loc, diagnostic)
    << Ty
    << StringRef(buffer.data(), buffer.size());
}

bool isExact = (result == APFloat::opOK);
return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc);
3720}

3722bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {
assert(E && "Invalid expression")(static_cast <bool> (E && "Invalid expression")
 ? void (0) : __assert_fail ("E && \"Invalid expression\""
, "clang/lib/Sema/SemaExpr.cpp", 3723, __extension__ __PRETTY_FUNCTION__
));

if (E->isValueDependent())
  return false;

QualType QT = E->getType();
if (!QT->isIntegerType() || QT->isBooleanType() || QT->isCharType()) {
  Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
  return true;
}

llvm::APSInt ValueAPS;
ExprResult R = VerifyIntegerConstantExpression(E, &ValueAPS);

if (R.isInvalid())
  return true;

bool ValueIsPositive = ValueAPS.isStrictlyPositive();
if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
  Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_value)
      << toString(ValueAPS, 10) << ValueIsPositive;
  return true;
}

return false;
3748}

3750ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Fast path for a single digit (which is quite common).  A single digit
// cannot have a trigraph, escaped newline, radix prefix, or suffix.
if (Tok.getLength() == 1) {
  const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
  return ActOnIntegerConstant(Tok.getLocation(), Val-'0');
}

SmallString<128> SpellingBuffer;
// NumericLiteralParser wants to overread by one character.  Add padding to
// the buffer in case the token is copied to the buffer.  If getSpelling()
// returns a StringRef to the memory buffer, it should have a null char at
// the EOF, so it is also safe.
SpellingBuffer.resize(Tok.getLength() + 1);

// Get the spelling of the token, which eliminates trigraphs, etc.
bool Invalid = false;
StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid);
if (Invalid)
  return ExprError();

NumericLiteralParser Literal(TokSpelling, Tok.getLocation(),
                             PP.getSourceManager(), PP.getLangOpts(),
                             PP.getTargetInfo(), PP.getDiagnostics());
if (Literal.hadError)
  return ExprError();

if (Literal.hasUDSuffix()) {
  // We're building a user-defined literal.
  const IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
  SourceLocation UDSuffixLoc =
    getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());

  // Make sure we're allowed user-defined literals here.
  if (!UDLScope)
    return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));

  QualType CookedTy;
  if (Literal.isFloatingLiteral()) {
    // C++11 [lex.ext]p4: If S contains a literal operator with parameter type
    // long double, the literal is treated as a call of the form
    //   operator "" X (f L)
    CookedTy = Context.LongDoubleTy;
  } else {
    // C++11 [lex.ext]p3: If S contains a literal operator with parameter type
    // unsigned long long, the literal is treated as a call of the form
    //   operator "" X (n ULL)
    CookedTy = Context.UnsignedLongLongTy;
  }

  DeclarationName OpName =
    Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);

  SourceLocation TokLoc = Tok.getLocation();

  // Perform literal operator lookup to determine if we're building a raw
  // literal or a cooked one.
  LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
  switch (LookupLiteralOperator(UDLScope, R, CookedTy,
                                /*AllowRaw*/ true, /*AllowTemplate*/ true,
                                /*AllowStringTemplatePack*/ false,
                                /*DiagnoseMissing*/ !Literal.isImaginary)) {
  case LOLR_ErrorNoDiagnostic:
    // Lookup failure for imaginary constants isn't fatal, there's still the
    // GNU extension producing _Complex types.
    break;
  case LOLR_Error:
    return ExprError();
  case LOLR_Cooked: {
    Expr *Lit;
    if (Literal.isFloatingLiteral()) {
      Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation());
    } else {
      llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0);
      if (Literal.GetIntegerValue(ResultVal))
        Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
            << /* Unsigned */ 1;
      Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy,
                                   Tok.getLocation());
    }
    return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
  }

  case LOLR_Raw: {
    // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the
    // literal is treated as a call of the form
    //   operator "" X ("n")
    unsigned Length = Literal.getUDSuffixOffset();
    QualType StrTy = Context.getConstantArrayType(
        Context.adjustStringLiteralBaseType(Context.CharTy.withConst()),
        llvm::APInt(32, Length + 1), nullptr, ArrayType::Normal, 0);
    Expr *Lit =
        StringLiteral::Create(Context, StringRef(TokSpelling.data(), Length),
                              StringLiteral::Ordinary,
                              /*Pascal*/ false, StrTy, &TokLoc, 1);
    return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
  }

  case LOLR_Template: {
    // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator
    // template), L is treated as a call fo the form
    //   operator "" X <'c1', 'c2', ... 'ck'>()
    // where n is the source character sequence c1 c2 ... ck.
    TemplateArgumentListInfo ExplicitArgs;
    unsigned CharBits = Context.getIntWidth(Context.CharTy);
    bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType();
    llvm::APSInt Value(CharBits, CharIsUnsigned);
    for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
      Value = TokSpelling[I];
      TemplateArgument Arg(Context, Value, Context.CharTy);
      TemplateArgumentLocInfo ArgInfo;
      ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
    }
    return BuildLiteralOperatorCall(R, OpNameInfo, std::nullopt, TokLoc,
                                    &ExplicitArgs);
  }
  case LOLR_StringTemplatePack:
    llvm_unreachable("unexpected literal operator lookup result")::llvm::llvm_unreachable_internal("unexpected literal operator lookup result"
, "clang/lib/Sema/SemaExpr.cpp", 3869);
  }
}

Expr *Res;

if (Literal.isFixedPointLiteral()) {
  QualType Ty;

  if (Literal.isAccum) {
    if (Literal.isHalf) {
      Ty = Context.ShortAccumTy;
    } else if (Literal.isLong) {
      Ty = Context.LongAccumTy;
    } else {
      Ty = Context.AccumTy;
    }
  } else if (Literal.isFract) {
    if (Literal.isHalf) {
      Ty = Context.ShortFractTy;
    } else if (Literal.isLong) {
      Ty = Context.LongFractTy;
    } else {
      Ty = Context.FractTy;
    }
  }

  if (Literal.isUnsigned) Ty = Context.getCorrespondingUnsignedType(Ty);

  bool isSigned = !Literal.isUnsigned;
  unsigned scale = Context.getFixedPointScale(Ty);
  unsigned bit_width = Context.getTypeInfo(Ty).Width;

  llvm::APInt Val(bit_width, 0, isSigned);
  bool Overflowed = Literal.GetFixedPointValue(Val, scale);
  bool ValIsZero = Val.isZero() && !Overflowed;

  auto MaxVal = Context.getFixedPointMax(Ty).getValue();
  if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
    // Clause 6.4.4 - The value of a constant shall be in the range of
    // representable values for its type, with exception for constants of a
    // fract type with a value of exactly 1; such a constant shall denote
    // the maximal value for the type.
    --Val;
  else if (Val.ugt(MaxVal) || Overflowed)
    Diag(Tok.getLocation(), diag::err_too_large_for_fixed_point);

  Res = FixedPointLiteral::CreateFromRawInt(Context, Val, Ty,
                                            Tok.getLocation(), scale);
} else if (Literal.isFloatingLiteral()) {
  QualType Ty;
  if (Literal.isHalf){
    if (getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()))
      Ty = Context.HalfTy;
    else {
      Diag(Tok.getLocation(), diag::err_half_const_requires_fp16);
      return ExprError();
    }
  } else if (Literal.isFloat)
    Ty = Context.FloatTy;
  else if (Literal.isLong)
    Ty = Context.LongDoubleTy;
  else if (Literal.isFloat16)
    Ty = Context.Float16Ty;
  else if (Literal.isFloat128)
    Ty = Context.Float128Ty;
  else
    Ty = Context.DoubleTy;

  Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());

  if (Ty == Context.DoubleTy) {
    if (getLangOpts().SinglePrecisionConstants) {
      if (Ty->castAs<BuiltinType>()->getKind() != BuiltinType::Float) {
        Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
      }
    } else if (getLangOpts().OpenCL && !getOpenCLOptions().isAvailableOption(
                                           "cl_khr_fp64", getLangOpts())) {
      // Impose single-precision float type when cl_khr_fp64 is not enabled.
      Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64)
          << (getLangOpts().getOpenCLCompatibleVersion() >= 300);
      Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
    }
  }
} else if (!Literal.isIntegerLiteral()) {
  return ExprError();
} else {
  QualType Ty;

  // 'z/uz' literals are a C++23 feature.
  if (Literal.isSizeT)
    Diag(Tok.getLocation(), getLangOpts().CPlusPlus
                                ? getLangOpts().CPlusPlus23
                                      ? diag::warn_cxx20_compat_size_t_suffix
                                      : diag::ext_cxx23_size_t_suffix
                                : diag::err_cxx23_size_t_suffix);

  // 'wb/uwb' literals are a C2x feature. We support _BitInt as a type in C++,
  // but we do not currently support the suffix in C++ mode because it's not
  // entirely clear whether WG21 will prefer this suffix to return a library
  // type such as std::bit_int instead of returning a _BitInt.
  if (Literal.isBitInt && !getLangOpts().CPlusPlus)
    PP.Diag(Tok.getLocation(), getLangOpts().C2x
                                   ? diag::warn_c2x_compat_bitint_suffix
                                   : diag::ext_c2x_bitint_suffix);

  // Get the value in the widest-possible width. What is "widest" depends on
  // whether the literal is a bit-precise integer or not. For a bit-precise
  // integer type, try to scan the source to determine how many bits are
  // needed to represent the value. This may seem a bit expensive, but trying
  // to get the integer value from an overly-wide APInt is *extremely*
  // expensive, so the naive approach of assuming
  // llvm::IntegerType::MAX_INT_BITS is a big performance hit.
  unsigned BitsNeeded =
      Literal.isBitInt ? llvm::APInt::getSufficientBitsNeeded(
                             Literal.getLiteralDigits(), Literal.getRadix())
                       : Context.getTargetInfo().getIntMaxTWidth();
  llvm::APInt ResultVal(BitsNeeded, 0);

  if (Literal.GetIntegerValue(ResultVal)) {
    // If this value didn't fit into uintmax_t, error and force to ull.
    Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
        << /* Unsigned */ 1;
    Ty = Context.UnsignedLongLongTy;
    assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&(static_cast <bool> (Context.getTypeSize(Ty) == ResultVal
.getBitWidth() && "long long is not intmax_t?") ? void
 (0) : __assert_fail ("Context.getTypeSize(Ty) == ResultVal.getBitWidth() && \"long long is not intmax_t?\""
, "clang/lib/Sema/SemaExpr.cpp", 3994, __extension__ __PRETTY_FUNCTION__
))
           "long long is not intmax_t?")(static_cast <bool> (Context.getTypeSize(Ty) == ResultVal
.getBitWidth() && "long long is not intmax_t?") ? void
 (0) : __assert_fail ("Context.getTypeSize(Ty) == ResultVal.getBitWidth() && \"long long is not intmax_t?\""
, "clang/lib/Sema/SemaExpr.cpp", 3994, __extension__ __PRETTY_FUNCTION__
));
  } else {
    // If this value fits into a ULL, try to figure out what else it fits into
    // according to the rules of C99 6.4.4.1p5.

    // Octal, Hexadecimal, and integers with a U suffix are allowed to
    // be an unsigned int.
    bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;

    // Check from smallest to largest, picking the smallest type we can.
    unsigned Width = 0;

    // Microsoft specific integer suffixes are explicitly sized.
    if (Literal.MicrosoftInteger) {
      if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
        Width = 8;
        Ty = Context.CharTy;
      } else {
        Width = Literal.MicrosoftInteger;
        Ty = Context.getIntTypeForBitwidth(Width,
                                           /*Signed=*/!Literal.isUnsigned);
      }
    }

    // Bit-precise integer literals are automagically-sized based on the
    // width required by the literal.
    if (Literal.isBitInt) {
      // The signed version has one more bit for the sign value. There are no
      // zero-width bit-precise integers, even if the literal value is 0.
      Width = std::max(ResultVal.getActiveBits(), 1u) +
              (Literal.isUnsigned ? 0u : 1u);

      // Diagnose if the width of the constant is larger than BITINT_MAXWIDTH,
      // and reset the type to the largest supported width.
      unsigned int MaxBitIntWidth =
          Context.getTargetInfo().getMaxBitIntWidth();
      if (Width > MaxBitIntWidth) {
        Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
            << Literal.isUnsigned;
        Width = MaxBitIntWidth;
      }

      // Reset the result value to the smaller APInt and select the correct
      // type to be used. Note, we zext even for signed values because the
      // literal itself is always an unsigned value (a preceeding - is a
      // unary operator, not part of the literal).
      ResultVal = ResultVal.zextOrTrunc(Width);
      Ty = Context.getBitIntType(Literal.isUnsigned, Width);
    }

    // Check C++23 size_t literals.
    if (Literal.isSizeT) {
      assert(!Literal.MicrosoftInteger &&(static_cast <bool> (!Literal.MicrosoftInteger &&
 "size_t literals can't be Microsoft literals") ? void (0) : __assert_fail
 ("!Literal.MicrosoftInteger && \"size_t literals can't be Microsoft literals\""
, "clang/lib/Sema/SemaExpr.cpp", 4047, __extension__ __PRETTY_FUNCTION__
))
             "size_t literals can't be Microsoft literals")(static_cast <bool> (!Literal.MicrosoftInteger &&
 "size_t literals can't be Microsoft literals") ? void (0) : __assert_fail
 ("!Literal.MicrosoftInteger && \"size_t literals can't be Microsoft literals\""
, "clang/lib/Sema/SemaExpr.cpp", 4047, __extension__ __PRETTY_FUNCTION__
));
      unsigned SizeTSize = Context.getTargetInfo().getTypeWidth(
          Context.getTargetInfo().getSizeType());

      // Does it fit in size_t?
      if (ResultVal.isIntN(SizeTSize)) {
        // Does it fit in ssize_t?
        if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
          Ty = Context.getSignedSizeType();
        else if (AllowUnsigned)
          Ty = Context.getSizeType();
        Width = SizeTSize;
      }
    }

    if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong &&
        !Literal.isSizeT) {
      // Are int/unsigned possibilities?
      unsigned IntSize = Context.getTargetInfo().getIntWidth();

      // Does it fit in a unsigned int?
      if (ResultVal.isIntN(IntSize)) {
        // Does it fit in a signed int?
        if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
          Ty = Context.IntTy;
        else if (AllowUnsigned)
          Ty = Context.UnsignedIntTy;
        Width = IntSize;
      }
    }

    // Are long/unsigned long possibilities?
    if (Ty.isNull() && !Literal.isLongLong && !Literal.isSizeT) {
      unsigned LongSize = Context.getTargetInfo().getLongWidth();

      // Does it fit in a unsigned long?
      if (ResultVal.isIntN(LongSize)) {
        // Does it fit in a signed long?
        if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
          Ty = Context.LongTy;
        else if (AllowUnsigned)
          Ty = Context.UnsignedLongTy;
        // Check according to the rules of C90 6.1.3.2p5. C++03 [lex.icon]p2
        // is compatible.
        else if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11) {
          const unsigned LongLongSize =
              Context.getTargetInfo().getLongLongWidth();
          Diag(Tok.getLocation(),
               getLangOpts().CPlusPlus
                   ? Literal.isLong
                         ? diag::warn_old_implicitly_unsigned_long_cxx
                         : /*C++98 UB*/ diag::
                               ext_old_implicitly_unsigned_long_cxx
                   : diag::warn_old_implicitly_unsigned_long)
              << (LongLongSize > LongSize ? /*will have type 'long long'*/ 0
                                          : /*will be ill-formed*/ 1);
          Ty = Context.UnsignedLongTy;
        }
        Width = LongSize;
      }
    }

    // Check long long if needed.
    if (Ty.isNull() && !Literal.isSizeT) {
      unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth();

      // Does it fit in a unsigned long long?
      if (ResultVal.isIntN(LongLongSize)) {
        // Does it fit in a signed long long?
        // To be compatible with MSVC, hex integer literals ending with the
        // LL or i64 suffix are always signed in Microsoft mode.
        if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
            (getLangOpts().MSVCCompat && Literal.isLongLong)))
          Ty = Context.LongLongTy;
        else if (AllowUnsigned)
          Ty = Context.UnsignedLongLongTy;
        Width = LongLongSize;

        // 'long long' is a C99 or C++11 feature, whether the literal
        // explicitly specified 'long long' or we needed the extra width.
        if (getLangOpts().CPlusPlus)
          Diag(Tok.getLocation(), getLangOpts().CPlusPlus11
                                      ? diag::warn_cxx98_compat_longlong
                                      : diag::ext_cxx11_longlong);
        else if (!getLangOpts().C99)
          Diag(Tok.getLocation(), diag::ext_c99_longlong);
      }
    }

    // If we still couldn't decide a type, we either have 'size_t' literal
    // that is out of range, or a decimal literal that does not fit in a
    // signed long long and has no U suffix.
    if (Ty.isNull()) {
      if (Literal.isSizeT)
        Diag(Tok.getLocation(), diag::err_size_t_literal_too_large)
            << Literal.isUnsigned;
      else
        Diag(Tok.getLocation(),
             diag::ext_integer_literal_too_large_for_signed);
      Ty = Context.UnsignedLongLongTy;
      Width = Context.getTargetInfo().getLongLongWidth();
    }

    if (ResultVal.getBitWidth() != Width)
      ResultVal = ResultVal.trunc(Width);
  }
  Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation());
}

// If this is an imaginary literal, create the ImaginaryLiteral wrapper.
if (Literal.isImaginary) {
  Res = new (Context) ImaginaryLiteral(Res,
                                      Context.getComplexType(Res->getType()));

  Diag(Tok.getLocation(), diag::ext_imaginary_constant);
}
return Res;
4164}

4166ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) {
assert(E && "ActOnParenExpr() missing expr")(static_cast <bool> (E && "ActOnParenExpr() missing expr"
) ? void (0) : __assert_fail ("E && \"ActOnParenExpr() missing expr\""
, "clang/lib/Sema/SemaExpr.cpp", 4167, __extension__ __PRETTY_FUNCTION__
));
QualType ExprTy = E->getType();
if (getLangOpts().ProtectParens && CurFPFeatures.getAllowFPReassociate() &&
    !E->isLValue() && ExprTy->hasFloatingRepresentation())
  return BuildBuiltinCallExpr(R, Builtin::BI__arithmetic_fence, E);
return new (Context) ParenExpr(L, R, E);
4173}

4175static bool CheckVecStepTraitOperandType(Sema &S, QualType T,
                                       SourceLocation Loc,
                                       SourceRange ArgRange) {
// [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in
// scalar or vector data type argument..."
// Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
// type (C99 6.2.5p18) or void.
if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
  S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
    << T << ArgRange;
  return true;
}

assert((T->isVoidType() || !T->isIncompleteType()) &&(static_cast <bool> ((T->isVoidType() || !T->isIncompleteType
()) && "Scalar types should always be complete") ? void
 (0) : __assert_fail ("(T->isVoidType() || !T->isIncompleteType()) && \"Scalar types should always be complete\""
, "clang/lib/Sema/SemaExpr.cpp", 4189, __extension__ __PRETTY_FUNCTION__
))
       "Scalar types should always be complete")(static_cast <bool> ((T->isVoidType() || !T->isIncompleteType
()) && "Scalar types should always be complete") ? void
 (0) : __assert_fail ("(T->isVoidType() || !T->isIncompleteType()) && \"Scalar types should always be complete\""
, "clang/lib/Sema/SemaExpr.cpp", 4189, __extension__ __PRETTY_FUNCTION__
));
return false;
4191}

4193static bool CheckExtensionTraitOperandType(Sema &S, QualType T,
                                         SourceLocation Loc,
                                         SourceRange ArgRange,
                                         UnaryExprOrTypeTrait TraitKind) {
// Invalid types must be hard errors for SFINAE in C++.
if (S.LangOpts.CPlusPlus)
  return true;

// C99 6.5.3.4p1:
if (T->isFunctionType() &&
    (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
     TraitKind == UETT_PreferredAlignOf)) {
  // sizeof(function)/alignof(function) is allowed as an extension.
  S.Diag(Loc, diag::ext_sizeof_alignof_function_type)
      << getTraitSpelling(TraitKind) << ArgRange;
  return false;
}

// Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where
// this is an error (OpenCL v1.1 s6.3.k)
if (T->isVoidType()) {
  unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
                                      : diag::ext_sizeof_alignof_void_type;
  S.Diag(Loc, DiagID) << getTraitSpelling(TraitKind) << ArgRange;
  return false;
}

return true;
4221}

4223static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T,
                                           SourceLocation Loc,
                                           SourceRange ArgRange,
                                           UnaryExprOrTypeTrait TraitKind) {
// Reject sizeof(interface) and sizeof(interface<proto>) if the
// runtime doesn't allow it.
if (!S.LangOpts.ObjCRuntime.allowsSizeofAlignof() && T->isObjCObjectType()) {
  S.Diag(Loc, diag::err_sizeof_nonfragile_interface)
    << T << (TraitKind == UETT_SizeOf)
    << ArgRange;
  return true;
}

return false;
4237}

4239/// Check whether E is a pointer from a decayed array type (the decayed
4240/// pointer type is equal to T) and emit a warning if it is.
4241static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T,
                                   const Expr *E) {
// Don't warn if the operation changed the type.
if (T != E->getType())
  return;

// Now look for array decays.
const auto *ICE = dyn_cast<ImplicitCastExpr>(E);
if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
  return;

S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
                                           << ICE->getType()
                                           << ICE->getSubExpr()->getType();
4255}

4257/// Check the constraints on expression operands to unary type expression
4258/// and type traits.
4259///
4260/// Completes any types necessary and validates the constraints on the operand
4261/// expression. The logic mostly mirrors the type-based overload, but may modify
4262/// the expression as it completes the type for that expression through template
4263/// instantiation, etc.
4264bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
                                          UnaryExprOrTypeTrait ExprKind) {
QualType ExprTy = E->getType();
assert(!ExprTy->isReferenceType())(static_cast <bool> (!ExprTy->isReferenceType()) ? void
 (0) : __assert_fail ("!ExprTy->isReferenceType()", "clang/lib/Sema/SemaExpr.cpp"
, 4267, __extension__ __PRETTY_FUNCTION__));

bool IsUnevaluatedOperand =
    (ExprKind == UETT_SizeOf || ExprKind == UETT_AlignOf ||
     ExprKind == UETT_PreferredAlignOf || ExprKind == UETT_VecStep);
if (IsUnevaluatedOperand) {
  ExprResult Result = CheckUnevaluatedOperand(E);
  if (Result.isInvalid())
    return true;
  E = Result.get();
}

// The operand for sizeof and alignof is in an unevaluated expression context,
// so side effects could result in unintended consequences.
// Exclude instantiation-dependent expressions, because 'sizeof' is sometimes
// used to build SFINAE gadgets.
// FIXME: Should we consider instantiation-dependent operands to 'alignof'?
if (IsUnevaluatedOperand && !inTemplateInstantiation() &&
    !E->isInstantiationDependent() &&
    !E->getType()->isVariableArrayType() &&
    E->HasSideEffects(Context, false))
  Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);

if (ExprKind == UETT_VecStep)
  return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(),
                                      E->getSourceRange());

// Explicitly list some types as extensions.
if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(),
                                    E->getSourceRange(), ExprKind))
  return false;

// 'alignof' applied to an expression only requires the base element type of
// the expression to be complete. 'sizeof' requires the expression's type to
// be complete (and will attempt to complete it if it's an array of unknown
// bound).
if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
  if (RequireCompleteSizedType(
          E->getExprLoc(), Context.getBaseElementType(E->getType()),
          diag::err_sizeof_alignof_incomplete_or_sizeless_type,
          getTraitSpelling(ExprKind), E->getSourceRange()))
    return true;
} else {
  if (RequireCompleteSizedExprType(
          E, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
          getTraitSpelling(ExprKind), E->getSourceRange()))
    return true;
}

// Completing the expression's type may have changed it.
ExprTy = E->getType();
assert(!ExprTy->isReferenceType())(static_cast <bool> (!ExprTy->isReferenceType()) ? void
 (0) : __assert_fail ("!ExprTy->isReferenceType()", "clang/lib/Sema/SemaExpr.cpp"
, 4318, __extension__ __PRETTY_FUNCTION__));

if (ExprTy->isFunctionType()) {
  Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type)
      << getTraitSpelling(ExprKind) << E->getSourceRange();
  return true;
}

if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(),
                                     E->getSourceRange(), ExprKind))
  return true;

if (ExprKind == UETT_SizeOf) {
  if (const auto *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
    if (const auto *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
      QualType OType = PVD->getOriginalType();
      QualType Type = PVD->getType();
      if (Type->isPointerType() && OType->isArrayType()) {
        Diag(E->getExprLoc(), diag::warn_sizeof_array_param)
          << Type << OType;
        Diag(PVD->getLocation(), diag::note_declared_at);
      }
    }
  }

  // Warn on "sizeof(array op x)" and "sizeof(x op array)", where the array
  // decays into a pointer and returns an unintended result. This is most
  // likely a typo for "sizeof(array) op x".
  if (const auto *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) {
    warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
                             BO->getLHS());
    warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
                             BO->getRHS());
  }
}

return false;
4355}

4357/// Check the constraints on operands to unary expression and type
4358/// traits.
4359///
4360/// This will complete any types necessary, and validate the various constraints
4361/// on those operands.
4362///
4363/// The UsualUnaryConversions() function is *not* called by this routine.
4364/// C99 6.3.2.1p[2-4] all state:
4365///   Except when it is the operand of the sizeof operator ...
4366///
4367/// C++ [expr.sizeof]p4
4368///   The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4369///   standard conversions are not applied to the operand of sizeof.
4370///
4371/// This policy is followed for all of the unary trait expressions.
4372bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
                                          SourceLocation OpLoc,
                                          SourceRange ExprRange,
                                          UnaryExprOrTypeTrait ExprKind) {
if (ExprType->isDependentType())
  return false;

// C++ [expr.sizeof]p2:
//     When applied to a reference or a reference type, the result
//     is the size of the referenced type.
// C++11 [expr.alignof]p3:
//     When alignof is applied to a reference type, the result
//     shall be the alignment of the referenced type.
if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
  ExprType = Ref->getPointeeType();

// C11 6.5.3.4/3, C++11 [expr.alignof]p3:
//   When alignof or _Alignof is applied to an array type, the result
//   is the alignment of the element type.
if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
    ExprKind == UETT_OpenMPRequiredSimdAlign)
  ExprType = Context.getBaseElementType(ExprType);

if (ExprKind == UETT_VecStep)
  return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);

// Explicitly list some types as extensions.
if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
                                    ExprKind))
  return false;

if (RequireCompleteSizedType(
        OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
        getTraitSpelling(ExprKind), ExprRange))
  return true;

if (ExprType->isFunctionType()) {
  Diag(OpLoc, diag::err_sizeof_alignof_function_type)
      << getTraitSpelling(ExprKind) << ExprRange;
  return true;
}

if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
                                     ExprKind))
  return true;

return false;
4419}

4421static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
// Cannot know anything else if the expression is dependent.
if (E->isTypeDependent())
  return false;

if (E->getObjectKind() == OK_BitField) {
  S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
     << 1 << E->getSourceRange();
  return true;
}

ValueDecl *D = nullptr;
Expr *Inner = E->IgnoreParens();
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Inner)) {
  D = DRE->getDecl();
} else if (MemberExpr *ME = dyn_cast<MemberExpr>(Inner)) {
  D = ME->getMemberDecl();
}

// If it's a field, require the containing struct to have a
// complete definition so that we can compute the layout.
//
// This can happen in C++11 onwards, either by naming the member
// in a way that is not transformed into a member access expression
// (in an unevaluated operand, for instance), or by naming the member
// in a trailing-return-type.
//
// For the record, since __alignof__ on expressions is a GCC
// extension, GCC seems to permit this but always gives the
// nonsensical answer 0.
//
// We don't really need the layout here --- we could instead just
// directly check for all the appropriate alignment-lowing
// attributes --- but that would require duplicating a lot of
// logic that just isn't worth duplicating for such a marginal
// use-case.
if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
  // Fast path this check, since we at least know the record has a
  // definition if we can find a member of it.
  if (!FD->getParent()->isCompleteDefinition()) {
    S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type)
      << E->getSourceRange();
    return true;
  }

  // Otherwise, if it's a field, and the field doesn't have
  // reference type, then it must have a complete type (or be a
  // flexible array member, which we explicitly want to
  // white-list anyway), which makes the following checks trivial.
  if (!FD->getType()->isReferenceType())
    return false;
}

return S.CheckUnaryExprOrTypeTraitOperand(E, ExprKind);
4475}

4477bool Sema::CheckVecStepExpr(Expr *E) {
E = E->IgnoreParens();

// Cannot know anything else if the expression is dependent.
if (E->isTypeDependent())
  return false;

return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep);
4485}

4487static void captureVariablyModifiedType(ASTContext &Context, QualType T,
                                      CapturingScopeInfo *CSI) {
assert(T->isVariablyModifiedType())(static_cast <bool> (T->isVariablyModifiedType()) ? void
 (0) : __assert_fail ("T->isVariablyModifiedType()", "clang/lib/Sema/SemaExpr.cpp"
, 4489, __extension__ __PRETTY_FUNCTION__));
assert(CSI != nullptr)(static_cast <bool> (CSI != nullptr) ? void (0) : __assert_fail
 ("CSI != nullptr", "clang/lib/Sema/SemaExpr.cpp", 4490, __extension__
 __PRETTY_FUNCTION__));

// We're going to walk down into the type and look for VLA expressions.
do {
  const Type *Ty = T.getTypePtr();
  switch (Ty->getTypeClass()) {
4496#define TYPE(Class, Base)
4497#define ABSTRACT_TYPE(Class, Base)
4498#define NON_CANONICAL_TYPE(Class, Base)
4499#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4500#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4501#include "clang/AST/TypeNodes.inc"
    T = QualType();
    break;
  // These types are never variably-modified.
  case Type::Builtin:
  case Type::Complex:
  case Type::Vector:
  case Type::ExtVector:
  case Type::ConstantMatrix:
  case Type::Record:
  case Type::Enum:
  case Type::TemplateSpecialization:
  case Type::ObjCObject:
  case Type::ObjCInterface:
  case Type::ObjCObjectPointer:
  case Type::ObjCTypeParam:
  case Type::Pipe:
  case Type::BitInt:
    llvm_unreachable("type class is never variably-modified!")::llvm::llvm_unreachable_internal("type class is never variably-modified!"
, "clang/lib/Sema/SemaExpr.cpp", 4519);
  case Type::Elaborated:
    T = cast<ElaboratedType>(Ty)->getNamedType();
    break;
  case Type::Adjusted:
    T = cast<AdjustedType>(Ty)->getOriginalType();
    break;
  case Type::Decayed:
    T = cast<DecayedType>(Ty)->getPointeeType();
    break;
  case Type::Pointer:
    T = cast<PointerType>(Ty)->getPointeeType();
    break;
  case Type::BlockPointer:
    T = cast<BlockPointerType>(Ty)->getPointeeType();
    break;
  case Type::LValueReference:
  case Type::RValueReference:
    T = cast<ReferenceType>(Ty)->getPointeeType();
    break;
  case Type::MemberPointer:
    T = cast<MemberPointerType>(Ty)->getPointeeType();
    break;
  case Type::ConstantArray:
  case Type::IncompleteArray:
    // Losing element qualification here is fine.
    T = cast<ArrayType>(Ty)->getElementType();
    break;
  case Type::VariableArray: {
    // Losing element qualification here is fine.
    const VariableArrayType *VAT = cast<VariableArrayType>(Ty);

    // Unknown size indication requires no size computation.
    // Otherwise, evaluate and record it.
    auto Size = VAT->getSizeExpr();
    if (Size && !CSI->isVLATypeCaptured(VAT) &&
        (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
      CSI->addVLATypeCapture(Size->getExprLoc(), VAT, Context.getSizeType());

    T = VAT->getElementType();
    break;
  }
  case Type::FunctionProto:
  case Type::FunctionNoProto:
    T = cast<FunctionType>(Ty)->getReturnType();
    break;
  case Type::Paren:
  case Type::TypeOf:
  case Type::UnaryTransform:
  case Type::Attributed:
  case Type::BTFTagAttributed:
  case Type::SubstTemplateTypeParm:
  case Type::MacroQualified:
    // Keep walking after single level desugaring.
    T = T.getSingleStepDesugaredType(Context);
    break;
  case Type::Typedef:
    T = cast<TypedefType>(Ty)->desugar();
    break;
  case Type::Decltype:
    T = cast<DecltypeType>(Ty)->desugar();
    break;
  case Type::Using:
    T = cast<UsingType>(Ty)->desugar();
    break;
  case Type::Auto:
  case Type::DeducedTemplateSpecialization:
    T = cast<DeducedType>(Ty)->getDeducedType();
    break;
  case Type::TypeOfExpr:
    T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
    break;
  case Type::Atomic:
    T = cast<AtomicType>(Ty)->getValueType();
    break;
  }
} while (!T.isNull() && T->isVariablyModifiedType());
4596}

4598/// Build a sizeof or alignof expression given a type operand.
4599ExprResult
4600Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
                                   SourceLocation OpLoc,
                                   UnaryExprOrTypeTrait ExprKind,
                                   SourceRange R) {
if (!TInfo)
  return ExprError();

QualType T = TInfo->getType();

if (!T->isDependentType() &&
    CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind))
  return ExprError();

if (T->isVariablyModifiedType() && FunctionScopes.size() > 1) {
  if (auto *TT = T->getAs<TypedefType>()) {
    for (auto I = FunctionScopes.rbegin(),
              E = std::prev(FunctionScopes.rend());
         I != E; ++I) {
      auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
      if (CSI == nullptr)
        break;
      DeclContext *DC = nullptr;
      if (auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
        DC = LSI->CallOperator;
      else if (auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
        DC = CRSI->TheCapturedDecl;
      else if (auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
        DC = BSI->TheDecl;
      if (DC) {
        if (DC->containsDecl(TT->getDecl()))
          break;
        captureVariablyModifiedType(Context, T, CSI);
      }
    }
  }
}

// C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
if (isUnevaluatedContext() && ExprKind == UETT_SizeOf &&
    TInfo->getType()->isVariablyModifiedType())
  TInfo = TransformToPotentiallyEvaluated(TInfo);

return new (Context) UnaryExprOrTypeTraitExpr(
    ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
4644}

4646/// Build a sizeof or alignof expression given an expression
4647/// operand.
4648ExprResult
4649Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
                                   UnaryExprOrTypeTrait ExprKind) {
ExprResult PE = CheckPlaceholderExpr(E);
if (PE.isInvalid())
  return ExprError();

E = PE.get();

// Verify that the operand is valid.
bool isInvalid = false;
if (E->isTypeDependent()) {
  // Delay type-checking for type-dependent expressions.
} else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
  isInvalid = CheckAlignOfExpr(*this, E, ExprKind);
} else if (ExprKind == UETT_VecStep) {
  isInvalid = CheckVecStepExpr(E);
} else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
    Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
    isInvalid = true;
} else if (E->refersToBitField()) {  // C99 6.5.3.4p1.
  Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
  isInvalid = true;
} else {
  isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf);
}

if (isInvalid)
  return ExprError();

if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) {
  PE = TransformToPotentiallyEvaluated(E);
  if (PE.isInvalid()) return ExprError();
  E = PE.get();
}

// C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
return new (Context) UnaryExprOrTypeTraitExpr(
    ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd());
4687}

4689/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
4690/// expr and the same for @c alignof and @c __alignof
4691/// Note that the ArgRange is invalid if isType is false.
4692ExprResult
4693Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
                                  UnaryExprOrTypeTrait ExprKind, bool IsType,
                                  void *TyOrEx, SourceRange ArgRange) {
// If error parsing type, ignore.
if (!TyOrEx) return ExprError();

if (IsType) {
  TypeSourceInfo *TInfo;
  (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
  return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
}

Expr *ArgEx = (Expr *)TyOrEx;
ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind);
return Result;
4708}

4710static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc,
                                   bool IsReal) {
if (V.get()->isTypeDependent())
  return S.Context.DependentTy;

// _Real and _Imag are only l-values for normal l-values.
if (V.get()->getObjectKind() != OK_Ordinary) {
  V = S.DefaultLvalueConversion(V.get());
  if (V.isInvalid())
    return QualType();
}

// These operators return the element type of a complex type.
if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>())
  return CT->getElementType();

// Otherwise they pass through real integer and floating point types here.
if (V.get()->getType()->isArithmeticType())
  return V.get()->getType();

// Test for placeholders.
ExprResult PR = S.CheckPlaceholderExpr(V.get());
if (PR.isInvalid()) return QualType();
if (PR.get() != V.get()) {
  V = PR;
  return CheckRealImagOperand(S, V, Loc, IsReal);
}

// Reject anything else.
S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType()
  << (IsReal ? "__real" : "__imag");
return QualType();
4742}



4746ExprResult
4747Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
                        tok::TokenKind Kind, Expr *Input) {
UnaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown unary op!")::llvm::llvm_unreachable_internal("Unknown unary op!", "clang/lib/Sema/SemaExpr.cpp"
, 4751);
case tok::plusplus:   Opc = UO_PostInc; break;
case tok::minusminus: Opc = UO_PostDec; break;
}

// Since this might is a postfix expression, get rid of ParenListExprs.
ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
if (Result.isInvalid()) return ExprError();
Input = Result.get();

return BuildUnaryOp(S, OpLoc, Opc, Input);
4762}

4764/// Diagnose if arithmetic on the given ObjC pointer is illegal.
4765///
4766/// \return true on error
4767static bool checkArithmeticOnObjCPointer(Sema &S,
                                       SourceLocation opLoc,
                                       Expr *op) {
assert(op->getType()->isObjCObjectPointerType())(static_cast <bool> (op->getType()->isObjCObjectPointerType
()) ? void (0) : __assert_fail ("op->getType()->isObjCObjectPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 4770, __extension__ __PRETTY_FUNCTION__
));
if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() &&
    !S.LangOpts.ObjCSubscriptingLegacyRuntime)
  return false;

S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
  << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
  << op->getSourceRange();
return true;
4779}

4781static bool isMSPropertySubscriptExpr(Sema &S, Expr *Base) {
auto *BaseNoParens = Base->IgnoreParens();
if (auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
  return MSProp->getPropertyDecl()->getType()->isArrayType();
return isa<MSPropertySubscriptExpr>(BaseNoParens);
4786}

4788// Returns the type used for LHS[RHS], given one of LHS, RHS is type-dependent.
4789// Typically this is DependentTy, but can sometimes be more precise.
4790//
4791// There are cases when we could determine a non-dependent type:
4792//  - LHS and RHS may have non-dependent types despite being type-dependent
4793//    (e.g. unbounded array static members of the current instantiation)
4794//  - one may be a dependent-sized array with known element type
4795//  - one may be a dependent-typed valid index (enum in current instantiation)
4796//
4797// We *always* return a dependent type, in such cases it is DependentTy.
4798// This avoids creating type-dependent expressions with non-dependent types.
4799// FIXME: is this important to avoid? See https://reviews.llvm.org/D107275
4800static QualType getDependentArraySubscriptType(Expr *LHS, Expr *RHS,
                                             const ASTContext &Ctx) {
assert(LHS->isTypeDependent() || RHS->isTypeDependent())(static_cast <bool> (LHS->isTypeDependent() || RHS->
isTypeDependent()) ? void (0) : __assert_fail ("LHS->isTypeDependent() || RHS->isTypeDependent()"
, "clang/lib/Sema/SemaExpr.cpp", 4802, __extension__ __PRETTY_FUNCTION__
));
QualType LTy = LHS->getType(), RTy = RHS->getType();
QualType Result = Ctx.DependentTy;
if (RTy->isIntegralOrUnscopedEnumerationType()) {
  if (const PointerType *PT = LTy->getAs<PointerType>())
    Result = PT->getPointeeType();
  else if (const ArrayType *AT = LTy->getAsArrayTypeUnsafe())
    Result = AT->getElementType();
} else if (LTy->isIntegralOrUnscopedEnumerationType()) {
  if (const PointerType *PT = RTy->getAs<PointerType>())
    Result = PT->getPointeeType();
  else if (const ArrayType *AT = RTy->getAsArrayTypeUnsafe())
    Result = AT->getElementType();
}
// Ensure we return a dependent type.
return Result->isDependentType() ? Result : Ctx.DependentTy;
4818}

4820static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args);

4822ExprResult Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base,
                                       SourceLocation lbLoc,
                                       MultiExprArg ArgExprs,
                                       SourceLocation rbLoc) {

if (base && !base->getType().isNull() &&
19
←
Assuming 'base' is null→
20
←
Taking false branch→
    base->hasPlaceholderType(BuiltinType::OMPArraySection))
  return ActOnOMPArraySectionExpr(base, lbLoc, ArgExprs.front(), SourceLocation(),
                                  SourceLocation(), /*Length*/ nullptr,
                                  /*Stride=*/nullptr, rbLoc);

// Since this might be a postfix expression, get rid of ParenListExprs.
if (isa<ParenListExpr>(base)) {
21
←
Assuming 'base' is not a 'ParenListExpr'→
22
←
Taking false branch→
  ExprResult result = MaybeConvertParenListExprToParenExpr(S, base);
  if (result.isInvalid())
    return ExprError();
  base = result.get();
}

// Check if base and idx form a MatrixSubscriptExpr.
//
// Helper to check for comma expressions, which are not allowed as indices for
// matrix subscript expressions.
auto CheckAndReportCommaError = [this, base, rbLoc](Expr *E) {
  if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isCommaOp()) {
    Diag(E->getExprLoc(), diag::err_matrix_subscript_comma)
        << SourceRange(base->getBeginLoc(), rbLoc);
    return true;
  }
  return false;
};
// The matrix subscript operator ([][])is considered a single operator.
// Separating the index expressions by parenthesis is not allowed.
if (base->hasPlaceholderType(BuiltinType::IncompleteMatrixIdx) &&
23
←
Called C++ object pointer is null
    !isa<MatrixSubscriptExpr>(base)) {
  Diag(base->getExprLoc(), diag::err_matrix_separate_incomplete_index)
      << SourceRange(base->getBeginLoc(), rbLoc);
  return ExprError();
}
// If the base is a MatrixSubscriptExpr, try to create a new
// MatrixSubscriptExpr.
auto *matSubscriptE = dyn_cast<MatrixSubscriptExpr>(base);
if (matSubscriptE) {
  assert(ArgExprs.size() == 1)(static_cast <bool> (ArgExprs.size() == 1) ? void (0) :
 __assert_fail ("ArgExprs.size() == 1", "clang/lib/Sema/SemaExpr.cpp"
, 4865, __extension__ __PRETTY_FUNCTION__));
  if (CheckAndReportCommaError(ArgExprs.front()))
    return ExprError();

  assert(matSubscriptE->isIncomplete() &&(static_cast <bool> (matSubscriptE->isIncomplete() &&
 "base has to be an incomplete matrix subscript") ? void (0) :
 __assert_fail ("matSubscriptE->isIncomplete() && \"base has to be an incomplete matrix subscript\""
, "clang/lib/Sema/SemaExpr.cpp", 4870, __extension__ __PRETTY_FUNCTION__
))
         "base has to be an incomplete matrix subscript")(static_cast <bool> (matSubscriptE->isIncomplete() &&
 "base has to be an incomplete matrix subscript") ? void (0) :
 __assert_fail ("matSubscriptE->isIncomplete() && \"base has to be an incomplete matrix subscript\""
, "clang/lib/Sema/SemaExpr.cpp", 4870, __extension__ __PRETTY_FUNCTION__
));
  return CreateBuiltinMatrixSubscriptExpr(matSubscriptE->getBase(),
                                          matSubscriptE->getRowIdx(),
                                          ArgExprs.front(), rbLoc);
}

// Handle any non-overload placeholder types in the base and index
// expressions.  We can't handle overloads here because the other
// operand might be an overloadable type, in which case the overload
// resolution for the operator overload should get the first crack
// at the overload.
bool IsMSPropertySubscript = false;
if (base->getType()->isNonOverloadPlaceholderType()) {
  IsMSPropertySubscript = isMSPropertySubscriptExpr(*this, base);
  if (!IsMSPropertySubscript) {
    ExprResult result = CheckPlaceholderExpr(base);
    if (result.isInvalid())
      return ExprError();
    base = result.get();
  }
}

// If the base is a matrix type, try to create a new MatrixSubscriptExpr.
if (base->getType()->isMatrixType()) {
  assert(ArgExprs.size() == 1)(static_cast <bool> (ArgExprs.size() == 1) ? void (0) :
 __assert_fail ("ArgExprs.size() == 1", "clang/lib/Sema/SemaExpr.cpp"
, 4894, __extension__ __PRETTY_FUNCTION__));
  if (CheckAndReportCommaError(ArgExprs.front()))
    return ExprError();

  return CreateBuiltinMatrixSubscriptExpr(base, ArgExprs.front(), nullptr,
                                          rbLoc);
}

if (ArgExprs.size() == 1 && getLangOpts().CPlusPlus20) {
  Expr *idx = ArgExprs[0];
  if ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
      (isa<CXXOperatorCallExpr>(idx) &&
       cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma)) {
    Diag(idx->getExprLoc(), diag::warn_deprecated_comma_subscript)
        << SourceRange(base->getBeginLoc(), rbLoc);
  }
}

if (ArgExprs.size() == 1 &&
    ArgExprs[0]->getType()->isNonOverloadPlaceholderType()) {
  ExprResult result = CheckPlaceholderExpr(ArgExprs[0]);
  if (result.isInvalid())
    return ExprError();
  ArgExprs[0] = result.get();
} else {
  if (checkArgsForPlaceholders(*this, ArgExprs))
    return ExprError();
}

// Build an unanalyzed expression if either operand is type-dependent.
if (getLangOpts().CPlusPlus && ArgExprs.size() == 1 &&
    (base->isTypeDependent() ||
     Expr::hasAnyTypeDependentArguments(ArgExprs)) &&
    !isa<PackExpansionExpr>(ArgExprs[0])) {
  return new (Context) ArraySubscriptExpr(
      base, ArgExprs.front(),
      getDependentArraySubscriptType(base, ArgExprs.front(), getASTContext()),
      VK_LValue, OK_Ordinary, rbLoc);
}

// MSDN, property (C++)
// https://msdn.microsoft.com/en-us/library/yhfk0thd(v=vs.120).aspx
// This attribute can also be used in the declaration of an empty array in a
// class or structure definition. For example:
// __declspec(property(get=GetX, put=PutX)) int x[];
// The above statement indicates that x[] can be used with one or more array
// indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b),
// and p->x[a][b] = i will be turned into p->PutX(a, b, i);
if (IsMSPropertySubscript) {
  assert(ArgExprs.size() == 1)(static_cast <bool> (ArgExprs.size() == 1) ? void (0) :
 __assert_fail ("ArgExprs.size() == 1", "clang/lib/Sema/SemaExpr.cpp"
, 4943, __extension__ __PRETTY_FUNCTION__));
  // Build MS property subscript expression if base is MS property reference
  // or MS property subscript.
  return new (Context)
      MSPropertySubscriptExpr(base, ArgExprs.front(), Context.PseudoObjectTy,
                              VK_LValue, OK_Ordinary, rbLoc);
}

// Use C++ overloaded-operator rules if either operand has record
// type.  The spec says to do this if either type is *overloadable*,
// but enum types can't declare subscript operators or conversion
// operators, so there's nothing interesting for overload resolution
// to do if there aren't any record types involved.
//
// ObjC pointers have their own subscripting logic that is not tied
// to overload resolution and so should not take this path.
if (getLangOpts().CPlusPlus && !base->getType()->isObjCObjectPointerType() &&
    ((base->getType()->isRecordType() ||
      (ArgExprs.size() != 1 || isa<PackExpansionExpr>(ArgExprs[0]) ||
       ArgExprs[0]->getType()->isRecordType())))) {
  return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, ArgExprs);
}

ExprResult Res =
    CreateBuiltinArraySubscriptExpr(base, lbLoc, ArgExprs.front(), rbLoc);

if (!Res.isInvalid() && isa<ArraySubscriptExpr>(Res.get()))
  CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.get()));

return Res;
4973}

4975ExprResult Sema::tryConvertExprToType(Expr *E, QualType Ty) {
InitializedEntity Entity = InitializedEntity::InitializeTemporary(Ty);
InitializationKind Kind =
    InitializationKind::CreateCopy(E->getBeginLoc(), SourceLocation());
InitializationSequence InitSeq(*this, Entity, Kind, E);
return InitSeq.Perform(*this, Entity, Kind, E);
4981}

4983ExprResult Sema::CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
                                                Expr *ColumnIdx,
                                                SourceLocation RBLoc) {
ExprResult BaseR = CheckPlaceholderExpr(Base);
if (BaseR.isInvalid())
  return BaseR;
Base = BaseR.get();

ExprResult RowR = CheckPlaceholderExpr(RowIdx);
if (RowR.isInvalid())
  return RowR;
RowIdx = RowR.get();

if (!ColumnIdx)
  return new (Context) MatrixSubscriptExpr(
      Base, RowIdx, ColumnIdx, Context.IncompleteMatrixIdxTy, RBLoc);

// Build an unanalyzed expression if any of the operands is type-dependent.
if (Base->isTypeDependent() || RowIdx->isTypeDependent() ||
    ColumnIdx->isTypeDependent())
  return new (Context) MatrixSubscriptExpr(Base, RowIdx, ColumnIdx,
                                           Context.DependentTy, RBLoc);

ExprResult ColumnR = CheckPlaceholderExpr(ColumnIdx);
if (ColumnR.isInvalid())
  return ColumnR;
ColumnIdx = ColumnR.get();

// Check that IndexExpr is an integer expression. If it is a constant
// expression, check that it is less than Dim (= the number of elements in the
// corresponding dimension).
auto IsIndexValid = [&](Expr *IndexExpr, unsigned Dim,
                        bool IsColumnIdx) -> Expr * {
  if (!IndexExpr->getType()->isIntegerType() &&
      !IndexExpr->isTypeDependent()) {
    Diag(IndexExpr->getBeginLoc(), diag::err_matrix_index_not_integer)
        << IsColumnIdx;
    return nullptr;
  }

  if (std::optional<llvm::APSInt> Idx =
          IndexExpr->getIntegerConstantExpr(Context)) {
    if ((*Idx < 0 || *Idx >= Dim)) {
      Diag(IndexExpr->getBeginLoc(), diag::err_matrix_index_outside_range)
          << IsColumnIdx << Dim;
      return nullptr;
    }
  }

  ExprResult ConvExpr =
      tryConvertExprToType(IndexExpr, Context.getSizeType());
  assert(!ConvExpr.isInvalid() &&(static_cast <bool> (!ConvExpr.isInvalid() && "should be able to convert any integer type to size type"
) ? void (0) : __assert_fail ("!ConvExpr.isInvalid() && \"should be able to convert any integer type to size type\""
, "clang/lib/Sema/SemaExpr.cpp", 5035, __extension__ __PRETTY_FUNCTION__
))
         "should be able to convert any integer type to size type")(static_cast <bool> (!ConvExpr.isInvalid() && "should be able to convert any integer type to size type"
) ? void (0) : __assert_fail ("!ConvExpr.isInvalid() && \"should be able to convert any integer type to size type\""
, "clang/lib/Sema/SemaExpr.cpp", 5035, __extension__ __PRETTY_FUNCTION__
));
  return ConvExpr.get();
};

auto *MTy = Base->getType()->getAs<ConstantMatrixType>();
RowIdx = IsIndexValid(RowIdx, MTy->getNumRows(), false);
ColumnIdx = IsIndexValid(ColumnIdx, MTy->getNumColumns(), true);
if (!RowIdx || !ColumnIdx)
  return ExprError();

return new (Context) MatrixSubscriptExpr(Base, RowIdx, ColumnIdx,
                                         MTy->getElementType(), RBLoc);
5047}

5049void Sema::CheckAddressOfNoDeref(const Expr *E) {
ExpressionEvaluationContextRecord &LastRecord = ExprEvalContexts.back();
const Expr *StrippedExpr = E->IgnoreParenImpCasts();

// For expressions like `&(*s).b`, the base is recorded and what should be
// checked.
const MemberExpr *Member = nullptr;
while ((Member = dyn_cast<MemberExpr>(StrippedExpr)) && !Member->isArrow())
  StrippedExpr = Member->getBase()->IgnoreParenImpCasts();

LastRecord.PossibleDerefs.erase(StrippedExpr);
5060}

5062void Sema::CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E) {
if (isUnevaluatedContext())
  return;

QualType ResultTy = E->getType();
ExpressionEvaluationContextRecord &LastRecord = ExprEvalContexts.back();

// Bail if the element is an array since it is not memory access.
if (isa<ArrayType>(ResultTy))
  return;

if (ResultTy->hasAttr(attr::NoDeref)) {
  LastRecord.PossibleDerefs.insert(E);
  return;
}

// Check if the base type is a pointer to a member access of a struct
// marked with noderef.
const Expr *Base = E->getBase();
QualType BaseTy = Base->getType();
if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
  // Not a pointer access
  return;

const MemberExpr *Member = nullptr;
while ((Member = dyn_cast<MemberExpr>(Base->IgnoreParenCasts())) &&
       Member->isArrow())
  Base = Member->getBase();

if (const auto *Ptr = dyn_cast<PointerType>(Base->getType())) {
  if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
    LastRecord.PossibleDerefs.insert(E);
}
5095}

5097ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
                                        Expr *LowerBound,
                                        SourceLocation ColonLocFirst,
                                        SourceLocation ColonLocSecond,
                                        Expr *Length, Expr *Stride,
                                        SourceLocation RBLoc) {
if (Base->hasPlaceholderType() &&
    !Base->hasPlaceholderType(BuiltinType::OMPArraySection)) {
  ExprResult Result = CheckPlaceholderExpr(Base);
  if (Result.isInvalid())
    return ExprError();
  Base = Result.get();
}
if (LowerBound && LowerBound->getType()->isNonOverloadPlaceholderType()) {
  ExprResult Result = CheckPlaceholderExpr(LowerBound);
  if (Result.isInvalid())
    return ExprError();
  Result = DefaultLvalueConversion(Result.get());
  if (Result.isInvalid())
    return ExprError();
  LowerBound = Result.get();
}
if (Length && Length->getType()->isNonOverloadPlaceholderType()) {
  ExprResult Result = CheckPlaceholderExpr(Length);
  if (Result.isInvalid())
    return ExprError();
  Result = DefaultLvalueConversion(Result.get());
  if (Result.isInvalid())
    return ExprError();
  Length = Result.get();
}
if (Stride && Stride->getType()->isNonOverloadPlaceholderType()) {
  ExprResult Result = CheckPlaceholderExpr(Stride);
  if (Result.isInvalid())
    return ExprError();
  Result = DefaultLvalueConversion(Result.get());
  if (Result.isInvalid())
    return ExprError();
  Stride = Result.get();
}

// Build an unanalyzed expression if either operand is type-dependent.
if (Base->isTypeDependent() ||
    (LowerBound &&
     (LowerBound->isTypeDependent() || LowerBound->isValueDependent())) ||
    (Length && (Length->isTypeDependent() || Length->isValueDependent())) ||
    (Stride && (Stride->isTypeDependent() || Stride->isValueDependent()))) {
  return new (Context) OMPArraySectionExpr(
      Base, LowerBound, Length, Stride, Context.DependentTy, VK_LValue,
      OK_Ordinary, ColonLocFirst, ColonLocSecond, RBLoc);
}

// Perform default conversions.
QualType OriginalTy = OMPArraySectionExpr::getBaseOriginalType(Base);
QualType ResultTy;
if (OriginalTy->isAnyPointerType()) {
  ResultTy = OriginalTy->getPointeeType();
} else if (OriginalTy->isArrayType()) {
  ResultTy = OriginalTy->getAsArrayTypeUnsafe()->getElementType();
} else {
  return ExprError(
      Diag(Base->getExprLoc(), diag::err_omp_typecheck_section_value)
      << Base->getSourceRange());
}
// C99 6.5.2.1p1
if (LowerBound) {
  auto Res = PerformOpenMPImplicitIntegerConversion(LowerBound->getExprLoc(),
                                                    LowerBound);
  if (Res.isInvalid())
    return ExprError(Diag(LowerBound->getExprLoc(),
                          diag::err_omp_typecheck_section_not_integer)
                     << 0 << LowerBound->getSourceRange());
  LowerBound = Res.get();

  if (LowerBound->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
      LowerBound->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
    Diag(LowerBound->getExprLoc(), diag::warn_omp_section_is_char)
        << 0 << LowerBound->getSourceRange();
}
if (Length) {
  auto Res =
      PerformOpenMPImplicitIntegerConversion(Length->getExprLoc(), Length);
  if (Res.isInvalid())
    return ExprError(Diag(Length->getExprLoc(),
                          diag::err_omp_typecheck_section_not_integer)
                     << 1 << Length->getSourceRange());
  Length = Res.get();

  if (Length->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
      Length->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
    Diag(Length->getExprLoc(), diag::warn_omp_section_is_char)
        << 1 << Length->getSourceRange();
}
if (Stride) {
  ExprResult Res =
      PerformOpenMPImplicitIntegerConversion(Stride->getExprLoc(), Stride);
  if (Res.isInvalid())
    return ExprError(Diag(Stride->getExprLoc(),
                          diag::err_omp_typecheck_section_not_integer)
                     << 1 << Stride->getSourceRange());
  Stride = Res.get();

  if (Stride->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
      Stride->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
    Diag(Stride->getExprLoc(), diag::warn_omp_section_is_char)
        << 1 << Stride->getSourceRange();
}

// C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
// C++ [expr.sub]p1: The type "T" shall be a completely-defined object
// type. Note that functions are not objects, and that (in C99 parlance)
// incomplete types are not object types.
if (ResultTy->isFunctionType()) {
  Diag(Base->getExprLoc(), diag::err_omp_section_function_type)
      << ResultTy << Base->getSourceRange();
  return ExprError();
}

if (RequireCompleteType(Base->getExprLoc(), ResultTy,
                        diag::err_omp_section_incomplete_type, Base))
  return ExprError();

if (LowerBound && !OriginalTy->isAnyPointerType()) {
  Expr::EvalResult Result;
  if (LowerBound->EvaluateAsInt(Result, Context)) {
    // OpenMP 5.0, [2.1.5 Array Sections]
    // The array section must be a subset of the original array.
    llvm::APSInt LowerBoundValue = Result.Val.getInt();
    if (LowerBoundValue.isNegative()) {
      Diag(LowerBound->getExprLoc(), diag::err_omp_section_not_subset_of_array)
          << LowerBound->getSourceRange();
      return ExprError();
    }
  }
}

if (Length) {
  Expr::EvalResult Result;
  if (Length->EvaluateAsInt(Result, Context)) {
    // OpenMP 5.0, [2.1.5 Array Sections]
    // The length must evaluate to non-negative integers.
    llvm::APSInt LengthValue = Result.Val.getInt();
    if (LengthValue.isNegative()) {
      Diag(Length->getExprLoc(), diag::err_omp_section_length_negative)
          << toString(LengthValue, /*Radix=*/10, /*Signed=*/true)
          << Length->getSourceRange();
      return ExprError();
    }
  }
} else if (ColonLocFirst.isValid() &&
           (OriginalTy.isNull() || (!OriginalTy->isConstantArrayType() &&
                                    !OriginalTy->isVariableArrayType()))) {
  // OpenMP 5.0, [2.1.5 Array Sections]
  // When the size of the array dimension is not known, the length must be
  // specified explicitly.
  Diag(ColonLocFirst, diag::err_omp_section_length_undefined)
      << (!OriginalTy.isNull() && OriginalTy->isArrayType());
  return ExprError();
}

if (Stride) {
  Expr::EvalResult Result;
  if (Stride->EvaluateAsInt(Result, Context)) {
    // OpenMP 5.0, [2.1.5 Array Sections]
    // The stride must evaluate to a positive integer.
    llvm::APSInt StrideValue = Result.Val.getInt();
    if (!StrideValue.isStrictlyPositive()) {
      Diag(Stride->getExprLoc(), diag::err_omp_section_stride_non_positive)
          << toString(StrideValue, /*Radix=*/10, /*Signed=*/true)
          << Stride->getSourceRange();
      return ExprError();
    }
  }
}

if (!Base->hasPlaceholderType(BuiltinType::OMPArraySection)) {
  ExprResult Result = DefaultFunctionArrayLvalueConversion(Base);
  if (Result.isInvalid())
    return ExprError();
  Base = Result.get();
}
return new (Context) OMPArraySectionExpr(
    Base, LowerBound, Length, Stride, Context.OMPArraySectionTy, VK_LValue,
    OK_Ordinary, ColonLocFirst, ColonLocSecond, RBLoc);
5281}

5283ExprResult Sema::ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
                                        SourceLocation RParenLoc,
                                        ArrayRef<Expr *> Dims,
                                        ArrayRef<SourceRange> Brackets) {
if (Base->hasPlaceholderType()) {
  ExprResult Result = CheckPlaceholderExpr(Base);
  if (Result.isInvalid())
    return ExprError();
  Result = DefaultLvalueConversion(Result.get());
  if (Result.isInvalid())
    return ExprError();
  Base = Result.get();
}
QualType BaseTy = Base->getType();
// Delay analysis of the types/expressions if instantiation/specialization is
// required.
if (!BaseTy->isPointerType() && Base->isTypeDependent())
  return OMPArrayShapingExpr::Create(Context, Context.DependentTy, Base,
                                     LParenLoc, RParenLoc, Dims, Brackets);
if (!BaseTy->isPointerType() ||
    (!Base->isTypeDependent() &&
     BaseTy->getPointeeType()->isIncompleteType()))
  return ExprError(Diag(Base->getExprLoc(),
                        diag::err_omp_non_pointer_type_array_shaping_base)
                   << Base->getSourceRange());

SmallVector<Expr *, 4> NewDims;
bool ErrorFound = false;
for (Expr *Dim : Dims) {
  if (Dim->hasPlaceholderType()) {
    ExprResult Result = CheckPlaceholderExpr(Dim);
    if (Result.isInvalid()) {
      ErrorFound = true;
      continue;
    }
    Result = DefaultLvalueConversion(Result.get());
    if (Result.isInvalid()) {
      ErrorFound = true;
      continue;
    }
    Dim = Result.get();
  }
  if (!Dim->isTypeDependent()) {
    ExprResult Result =
        PerformOpenMPImplicitIntegerConversion(Dim->getExprLoc(), Dim);
    if (Result.isInvalid()) {
      ErrorFound = true;
      Diag(Dim->getExprLoc(), diag::err_omp_typecheck_shaping_not_integer)
          << Dim->getSourceRange();
      continue;
    }
    Dim = Result.get();
    Expr::EvalResult EvResult;
    if (!Dim->isValueDependent() && Dim->EvaluateAsInt(EvResult, Context)) {
      // OpenMP 5.0, [2.1.4 Array Shaping]
      // Each si is an integral type expression that must evaluate to a
      // positive integer.
      llvm::APSInt Value = EvResult.Val.getInt();
      if (!Value.isStrictlyPositive()) {
        Diag(Dim->getExprLoc(), diag::err_omp_shaping_dimension_not_positive)
            << toString(Value, /*Radix=*/10, /*Signed=*/true)
            << Dim->getSourceRange();
        ErrorFound = true;
        continue;
      }
    }
  }
  NewDims.push_back(Dim);
}
if (ErrorFound)
  return ExprError();
return OMPArrayShapingExpr::Create(Context, Context.OMPArrayShapingTy, Base,
                                   LParenLoc, RParenLoc, NewDims, Brackets);
5356}

5358ExprResult Sema::ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,
                                    SourceLocation LLoc, SourceLocation RLoc,
                                    ArrayRef<OMPIteratorData> Data) {
SmallVector<OMPIteratorExpr::IteratorDefinition, 4> ID;
bool IsCorrect = true;
for (const OMPIteratorData &D : Data) {
  TypeSourceInfo *TInfo = nullptr;
  SourceLocation StartLoc;
  QualType DeclTy;
  if (!D.Type.getAsOpaquePtr()) {
    // OpenMP 5.0, 2.1.6 Iterators
    // In an iterator-specifier, if the iterator-type is not specified then
    // the type of that iterator is of int type.
    DeclTy = Context.IntTy;
    StartLoc = D.DeclIdentLoc;
  } else {
    DeclTy = GetTypeFromParser(D.Type, &TInfo);
    StartLoc = TInfo->getTypeLoc().getBeginLoc();
  }

  bool IsDeclTyDependent = DeclTy->isDependentType() ||
                           DeclTy->containsUnexpandedParameterPack() ||
                           DeclTy->isInstantiationDependentType();
  if (!IsDeclTyDependent) {
    if (!DeclTy->isIntegralType(Context) && !DeclTy->isAnyPointerType()) {
      // OpenMP 5.0, 2.1.6 Iterators, Restrictions, C/C++
      // The iterator-type must be an integral or pointer type.
      Diag(StartLoc, diag::err_omp_iterator_not_integral_or_pointer)
          << DeclTy;
      IsCorrect = false;
      continue;
    }
    if (DeclTy.isConstant(Context)) {
      // OpenMP 5.0, 2.1.6 Iterators, Restrictions, C/C++
      // The iterator-type must not be const qualified.
      Diag(StartLoc, diag::err_omp_iterator_not_integral_or_pointer)
          << DeclTy;
      IsCorrect = false;
      continue;
    }
  }

  // Iterator declaration.
  assert(D.DeclIdent && "Identifier expected.")(static_cast <bool> (D.DeclIdent && "Identifier expected."
) ? void (0) : __assert_fail ("D.DeclIdent && \"Identifier expected.\""
, "clang/lib/Sema/SemaExpr.cpp", 5401, __extension__ __PRETTY_FUNCTION__
));
  // Always try to create iterator declarator to avoid extra error messages
  // about unknown declarations use.
  auto *VD = VarDecl::Create(Context, CurContext, StartLoc, D.DeclIdentLoc,
                             D.DeclIdent, DeclTy, TInfo, SC_None);
  VD->setImplicit();
  if (S) {
    // Check for conflicting previous declaration.
    DeclarationNameInfo NameInfo(VD->getDeclName(), D.DeclIdentLoc);
    LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                          ForVisibleRedeclaration);
    Previous.suppressDiagnostics();
    LookupName(Previous, S);

    FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage=*/false,
                         /*AllowInlineNamespace=*/false);
    if (!Previous.empty()) {
      NamedDecl *Old = Previous.getRepresentativeDecl();
      Diag(D.DeclIdentLoc, diag::err_redefinition) << VD->getDeclName();
      Diag(Old->getLocation(), diag::note_previous_definition);
    } else {
      PushOnScopeChains(VD, S);
    }
  } else {
    CurContext->addDecl(VD);
  }

  /// Act on the iterator variable declaration.
  ActOnOpenMPIteratorVarDecl(VD);

  Expr *Begin = D.Range.Begin;
  if (!IsDeclTyDependent && Begin && !Begin->isTypeDependent()) {
    ExprResult BeginRes =
        PerformImplicitConversion(Begin, DeclTy, AA_Converting);
    Begin = BeginRes.get();
  }
  Expr *End = D.Range.End;
  if (!IsDeclTyDependent && End && !End->isTypeDependent()) {
    ExprResult EndRes = PerformImplicitConversion(End, DeclTy, AA_Converting);
    End = EndRes.get();
  }
  Expr *Step = D.Range.Step;
  if (!IsDeclTyDependent && Step && !Step->isTypeDependent()) {
    if (!Step->getType()->isIntegralType(Context)) {
      Diag(Step->getExprLoc(), diag::err_omp_iterator_step_not_integral)
          << Step << Step->getSourceRange();
      IsCorrect = false;
      continue;
    }
    std::optional<llvm::APSInt> Result =
        Step->getIntegerConstantExpr(Context);
    // OpenMP 5.0, 2.1.6 Iterators, Restrictions
    // If the step expression of a range-specification equals zero, the
    // behavior is unspecified.
    if (Result && Result->isZero()) {
      Diag(Step->getExprLoc(), diag::err_omp_iterator_step_constant_zero)
          << Step << Step->getSourceRange();
      IsCorrect = false;
      continue;
    }
  }
  if (!Begin || !End || !IsCorrect) {
    IsCorrect = false;
    continue;
  }
  OMPIteratorExpr::IteratorDefinition &IDElem = ID.emplace_back();
  IDElem.IteratorDecl = VD;
  IDElem.AssignmentLoc = D.AssignLoc;
  IDElem.Range.Begin = Begin;
  IDElem.Range.End = End;
  IDElem.Range.Step = Step;
  IDElem.ColonLoc = D.ColonLoc;
  IDElem.SecondColonLoc = D.SecColonLoc;
}
if (!IsCorrect) {
  // Invalidate all created iterator declarations if error is found.
  for (const OMPIteratorExpr::IteratorDefinition &D : ID) {
    if (Decl *ID = D.IteratorDecl)
      ID->setInvalidDecl();
  }
  return ExprError();
}
SmallVector<OMPIteratorHelperData, 4> Helpers;
if (!CurContext->isDependentContext()) {
  // Build number of ityeration for each iteration range.
  // Ni = ((Stepi > 0) ? ((Endi + Stepi -1 - Begini)/Stepi) :
  // ((Begini-Stepi-1-Endi) / -Stepi);
  for (OMPIteratorExpr::IteratorDefinition &D : ID) {
    // (Endi - Begini)
    ExprResult Res = CreateBuiltinBinOp(D.AssignmentLoc, BO_Sub, D.Range.End,
                                        D.Range.Begin);
    if(!Res.isUsable()) {
      IsCorrect = false;
      continue;
    }
    ExprResult St, St1;
    if (D.Range.Step) {
      St = D.Range.Step;
      // (Endi - Begini) + Stepi
      Res = CreateBuiltinBinOp(D.AssignmentLoc, BO_Add, Res.get(), St.get());
      if (!Res.isUsable()) {
        IsCorrect = false;
        continue;
      }
      // (Endi - Begini) + Stepi - 1
      Res =
          CreateBuiltinBinOp(D.AssignmentLoc, BO_Sub, Res.get(),
                             ActOnIntegerConstant(D.AssignmentLoc, 1).get());
      if (!Res.isUsable()) {
        IsCorrect = false;
        continue;
      }
      // ((Endi - Begini) + Stepi - 1) / Stepi
      Res = CreateBuiltinBinOp(D.AssignmentLoc, BO_Div, Res.get(), St.get());
      if (!Res.isUsable()) {
        IsCorrect = false;
        continue;
      }
      St1 = CreateBuiltinUnaryOp(D.AssignmentLoc, UO_Minus, D.Range.Step);
      // (Begini - Endi)
      ExprResult Res1 = CreateBuiltinBinOp(D.AssignmentLoc, BO_Sub,
                                           D.Range.Begin, D.Range.End);
      if (!Res1.isUsable()) {
        IsCorrect = false;
        continue;
      }
      // (Begini - Endi) - Stepi
      Res1 =
          CreateBuiltinBinOp(D.AssignmentLoc, BO_Add, Res1.get(), St1.get());
      if (!Res1.isUsable()) {
        IsCorrect = false;
        continue;
      }
      // (Begini - Endi) - Stepi - 1
      Res1 =
          CreateBuiltinBinOp(D.AssignmentLoc, BO_Sub, Res1.get(),
                             ActOnIntegerConstant(D.AssignmentLoc, 1).get());
      if (!Res1.isUsable()) {
        IsCorrect = false;
        continue;
      }
      // ((Begini - Endi) - Stepi - 1) / (-Stepi)
      Res1 =
          CreateBuiltinBinOp(D.AssignmentLoc, BO_Div, Res1.get(), St1.get());
      if (!Res1.isUsable()) {
        IsCorrect = false;
        continue;
      }
      // Stepi > 0.
      ExprResult CmpRes =
          CreateBuiltinBinOp(D.AssignmentLoc, BO_GT, D.Range.Step,
                             ActOnIntegerConstant(D.AssignmentLoc, 0).get());
      if (!CmpRes.isUsable()) {
        IsCorrect = false;
        continue;
      }
      Res = ActOnConditionalOp(D.AssignmentLoc, D.AssignmentLoc, CmpRes.get(),
                               Res.get(), Res1.get());
      if (!Res.isUsable()) {
        IsCorrect = false;
        continue;
      }
    }
    Res = ActOnFinishFullExpr(Res.get(), /*DiscardedValue=*/false);
    if (!Res.isUsable()) {
      IsCorrect = false;
      continue;
    }

    // Build counter update.
    // Build counter.
    auto *CounterVD =
        VarDecl::Create(Context, CurContext, D.IteratorDecl->getBeginLoc(),
                        D.IteratorDecl->getBeginLoc(), nullptr,
                        Res.get()->getType(), nullptr, SC_None);
    CounterVD->setImplicit();
    ExprResult RefRes =
        BuildDeclRefExpr(CounterVD, CounterVD->getType(), VK_LValue,
                         D.IteratorDecl->getBeginLoc());
    // Build counter update.
    // I = Begini + counter * Stepi;
    ExprResult UpdateRes;
    if (D.Range.Step) {
      UpdateRes = CreateBuiltinBinOp(
          D.AssignmentLoc, BO_Mul,
          DefaultLvalueConversion(RefRes.get()).get(), St.get());
    } else {
      UpdateRes = DefaultLvalueConversion(RefRes.get());
    }
    if (!UpdateRes.isUsable()) {
      IsCorrect = false;
      continue;
    }
    UpdateRes = CreateBuiltinBinOp(D.AssignmentLoc, BO_Add, D.Range.Begin,
                                   UpdateRes.get());
    if (!UpdateRes.isUsable()) {
      IsCorrect = false;
      continue;
    }
    ExprResult VDRes =
        BuildDeclRefExpr(cast<VarDecl>(D.IteratorDecl),
                         cast<VarDecl>(D.IteratorDecl)->getType(), VK_LValue,
                         D.IteratorDecl->getBeginLoc());
    UpdateRes = CreateBuiltinBinOp(D.AssignmentLoc, BO_Assign, VDRes.get(),
                                   UpdateRes.get());
    if (!UpdateRes.isUsable()) {
      IsCorrect = false;
      continue;
    }
    UpdateRes =
        ActOnFinishFullExpr(UpdateRes.get(), /*DiscardedValue=*/true);
    if (!UpdateRes.isUsable()) {
      IsCorrect = false;
      continue;
    }
    ExprResult CounterUpdateRes =
        CreateBuiltinUnaryOp(D.AssignmentLoc, UO_PreInc, RefRes.get());
    if (!CounterUpdateRes.isUsable()) {
      IsCorrect = false;
      continue;
    }
    CounterUpdateRes =
        ActOnFinishFullExpr(CounterUpdateRes.get(), /*DiscardedValue=*/true);
    if (!CounterUpdateRes.isUsable()) {
      IsCorrect = false;
      continue;
    }
    OMPIteratorHelperData &HD = Helpers.emplace_back();
    HD.CounterVD = CounterVD;
    HD.Upper = Res.get();
    HD.Update = UpdateRes.get();
    HD.CounterUpdate = CounterUpdateRes.get();
  }
} else {
  Helpers.assign(ID.size(), {});
}
if (!IsCorrect) {
  // Invalidate all created iterator declarations if error is found.
  for (const OMPIteratorExpr::IteratorDefinition &D : ID) {
    if (Decl *ID = D.IteratorDecl)
      ID->setInvalidDecl();
  }
  return ExprError();
}
return OMPIteratorExpr::Create(Context, Context.OMPIteratorTy, IteratorKwLoc,
                               LLoc, RLoc, ID, Helpers);
5647}

5649ExprResult
5650Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
                                    Expr *Idx, SourceLocation RLoc) {
Expr *LHSExp = Base;
Expr *RHSExp = Idx;

ExprValueKind VK = VK_LValue;
ExprObjectKind OK = OK_Ordinary;

// Per C++ core issue 1213, the result is an xvalue if either operand is
// a non-lvalue array, and an lvalue otherwise.
if (getLangOpts().CPlusPlus11) {
  for (auto *Op : {LHSExp, RHSExp}) {
    Op = Op->IgnoreImplicit();
    if (Op->getType()->isArrayType() && !Op->isLValue())
      VK = VK_XValue;
  }
}

// Perform default conversions.
if (!LHSExp->getType()->getAs<VectorType>()) {
  ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
  if (Result.isInvalid())
    return ExprError();
  LHSExp = Result.get();
}
ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
if (Result.isInvalid())
  return ExprError();
RHSExp = Result.get();

QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();

// C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
// to the expression *((e1)+(e2)). This means the array "Base" may actually be
// in the subscript position. As a result, we need to derive the array base
// and index from the expression types.
Expr *BaseExpr, *IndexExpr;
QualType ResultType;
if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
  BaseExpr = LHSExp;
  IndexExpr = RHSExp;
  ResultType =
      getDependentArraySubscriptType(LHSExp, RHSExp, getASTContext());
} else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) {
  BaseExpr = LHSExp;
  IndexExpr = RHSExp;
  ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy =
             LHSTy->getAs<ObjCObjectPointerType>()) {
  BaseExpr = LHSExp;
  IndexExpr = RHSExp;

  // Use custom logic if this should be the pseudo-object subscript
  // expression.
  if (!LangOpts.isSubscriptPointerArithmetic())
    return BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, nullptr,
                                        nullptr);

  ResultType = PTy->getPointeeType();
} else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
   // Handle the uncommon case of "123[Ptr]".
  BaseExpr = RHSExp;
  IndexExpr = LHSExp;
  ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy =
             RHSTy->getAs<ObjCObjectPointerType>()) {
   // Handle the uncommon case of "123[Ptr]".
  BaseExpr = RHSExp;
  IndexExpr = LHSExp;
  ResultType = PTy->getPointeeType();
  if (!LangOpts.isSubscriptPointerArithmetic()) {
    Diag(LLoc, diag::err_subscript_nonfragile_interface)
      << ResultType << BaseExpr->getSourceRange();
    return ExprError();
  }
} else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) {
  BaseExpr = LHSExp;    // vectors: V[123]
  IndexExpr = RHSExp;
  // We apply C++ DR1213 to vector subscripting too.
  if (getLangOpts().CPlusPlus11 && LHSExp->isPRValue()) {
    ExprResult Materialized = TemporaryMaterializationConversion(LHSExp);
    if (Materialized.isInvalid())
      return ExprError();
    LHSExp = Materialized.get();
  }
  VK = LHSExp->getValueKind();
  if (VK != VK_PRValue)
    OK = OK_VectorComponent;

  ResultType = VTy->getElementType();
  QualType BaseType = BaseExpr->getType();
  Qualifiers BaseQuals = BaseType.getQualifiers();
  Qualifiers MemberQuals = ResultType.getQualifiers();
  Qualifiers Combined = BaseQuals + MemberQuals;
  if (Combined != MemberQuals)
    ResultType = Context.getQualifiedType(ResultType, Combined);
} else if (LHSTy->isBuiltinType() &&
           LHSTy->getAs<BuiltinType>()->isVLSTBuiltinType()) {
  const BuiltinType *BTy = LHSTy->getAs<BuiltinType>();
  if (BTy->isSVEBool())
    return ExprError(Diag(LLoc, diag::err_subscript_svbool_t)
                     << LHSExp->getSourceRange() << RHSExp->getSourceRange());

  BaseExpr = LHSExp;
  IndexExpr = RHSExp;
  if (getLangOpts().CPlusPlus11 && LHSExp->isPRValue()) {
    ExprResult Materialized = TemporaryMaterializationConversion(LHSExp);
    if (Materialized.isInvalid())
      return ExprError();
    LHSExp = Materialized.get();
  }
  VK = LHSExp->getValueKind();
  if (VK != VK_PRValue)
    OK = OK_VectorComponent;

  ResultType = BTy->getSveEltType(Context);

  QualType BaseType = BaseExpr->getType();
  Qualifiers BaseQuals = BaseType.getQualifiers();
  Qualifiers MemberQuals = ResultType.getQualifiers();
  Qualifiers Combined = BaseQuals + MemberQuals;
  if (Combined != MemberQuals)
    ResultType = Context.getQualifiedType(ResultType, Combined);
} else if (LHSTy->isArrayType()) {
  // If we see an array that wasn't promoted by
  // DefaultFunctionArrayLvalueConversion, it must be an array that
  // wasn't promoted because of the C90 rule that doesn't
  // allow promoting non-lvalue arrays.  Warn, then
  // force the promotion here.
  Diag(LHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
      << LHSExp->getSourceRange();
  LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
                             CK_ArrayToPointerDecay).get();
  LHSTy = LHSExp->getType();

  BaseExpr = LHSExp;
  IndexExpr = RHSExp;
  ResultType = LHSTy->castAs<PointerType>()->getPointeeType();
} else if (RHSTy->isArrayType()) {
  // Same as previous, except for 123[f().a] case
  Diag(RHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
      << RHSExp->getSourceRange();
  RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
                             CK_ArrayToPointerDecay).get();
  RHSTy = RHSExp->getType();

  BaseExpr = RHSExp;
  IndexExpr = LHSExp;
  ResultType = RHSTy->castAs<PointerType>()->getPointeeType();
} else {
  return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
     << LHSExp->getSourceRange() << RHSExp->getSourceRange());
}
// C99 6.5.2.1p1
if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
  return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
                   << IndexExpr->getSourceRange());

if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
     IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
       && !IndexExpr->isTypeDependent())
  Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange();

// C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
// C++ [expr.sub]p1: The type "T" shall be a completely-defined object
// type. Note that Functions are not objects, and that (in C99 parlance)
// incomplete types are not object types.
if (ResultType->isFunctionType()) {
  Diag(BaseExpr->getBeginLoc(), diag::err_subscript_function_type)
      << ResultType << BaseExpr->getSourceRange();
  return ExprError();
}

if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
  // GNU extension: subscripting on pointer to void
  Diag(LLoc, diag::ext_gnu_subscript_void_type)
    << BaseExpr->getSourceRange();

  // C forbids expressions of unqualified void type from being l-values.
  // See IsCForbiddenLValueType.
  if (!ResultType.hasQualifiers())
    VK = VK_PRValue;
} else if (!ResultType->isDependentType() &&
           RequireCompleteSizedType(
               LLoc, ResultType,
               diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
  return ExprError();

assert(VK == VK_PRValue || LangOpts.CPlusPlus ||(static_cast <bool> (VK == VK_PRValue || LangOpts.CPlusPlus
 || !ResultType.isCForbiddenLValueType()) ? void (0) : __assert_fail
 ("VK == VK_PRValue || LangOpts.CPlusPlus || !ResultType.isCForbiddenLValueType()"
, "clang/lib/Sema/SemaExpr.cpp", 5839, __extension__ __PRETTY_FUNCTION__
))
       !ResultType.isCForbiddenLValueType())(static_cast <bool> (VK == VK_PRValue || LangOpts.CPlusPlus
 || !ResultType.isCForbiddenLValueType()) ? void (0) : __assert_fail
 ("VK == VK_PRValue || LangOpts.CPlusPlus || !ResultType.isCForbiddenLValueType()"
, "clang/lib/Sema/SemaExpr.cpp", 5839, __extension__ __PRETTY_FUNCTION__
));

if (LHSExp->IgnoreParenImpCasts()->getType()->isVariablyModifiedType() &&
    FunctionScopes.size() > 1) {
  if (auto *TT =
          LHSExp->IgnoreParenImpCasts()->getType()->getAs<TypedefType>()) {
    for (auto I = FunctionScopes.rbegin(),
              E = std::prev(FunctionScopes.rend());
         I != E; ++I) {
      auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
      if (CSI == nullptr)
        break;
      DeclContext *DC = nullptr;
      if (auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
        DC = LSI->CallOperator;
      else if (auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
        DC = CRSI->TheCapturedDecl;
      else if (auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
        DC = BSI->TheDecl;
      if (DC) {
        if (DC->containsDecl(TT->getDecl()))
          break;
        captureVariablyModifiedType(
            Context, LHSExp->IgnoreParenImpCasts()->getType(), CSI);
      }
    }
  }
}

return new (Context)
    ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc);
5870}

5872bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
                                ParmVarDecl *Param, Expr *RewrittenInit,
                                bool SkipImmediateInvocations) {
if (Param->hasUnparsedDefaultArg()) {
  assert(!RewrittenInit && "Should not have a rewritten init expression yet")(static_cast <bool> (!RewrittenInit && "Should not have a rewritten init expression yet"
) ? void (0) : __assert_fail ("!RewrittenInit && \"Should not have a rewritten init expression yet\""
, "clang/lib/Sema/SemaExpr.cpp", 5876, __extension__ __PRETTY_FUNCTION__
));
  // If we've already cleared out the location for the default argument,
  // that means we're parsing it right now.
  if (!UnparsedDefaultArgLocs.count(Param)) {
    Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
    Diag(CallLoc, diag::note_recursive_default_argument_used_here);
    Param->setInvalidDecl();
    return true;
  }

  Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later)
      << FD << cast<CXXRecordDecl>(FD->getDeclContext());
  Diag(UnparsedDefaultArgLocs[Param],
       diag::note_default_argument_declared_here);
  return true;
}

if (Param->hasUninstantiatedDefaultArg()) {
  assert(!RewrittenInit && "Should not have a rewitten init expression yet")(static_cast <bool> (!RewrittenInit && "Should not have a rewitten init expression yet"
) ? void (0) : __assert_fail ("!RewrittenInit && \"Should not have a rewitten init expression yet\""
, "clang/lib/Sema/SemaExpr.cpp", 5894, __extension__ __PRETTY_FUNCTION__
));
  if (InstantiateDefaultArgument(CallLoc, FD, Param))
    return true;
}

Expr *Init = RewrittenInit ? RewrittenInit : Param->getInit();
assert(Init && "default argument but no initializer?")(static_cast <bool> (Init && "default argument but no initializer?"
) ? void (0) : __assert_fail ("Init && \"default argument but no initializer?\""
, "clang/lib/Sema/SemaExpr.cpp", 5900, __extension__ __PRETTY_FUNCTION__
));

// If the default expression creates temporaries, we need to
// push them to the current stack of expression temporaries so they'll
// be properly destroyed.
// FIXME: We should really be rebuilding the default argument with new
// bound temporaries; see the comment in PR5810.
// We don't need to do that with block decls, though, because
// blocks in default argument expression can never capture anything.
if (auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(Init)) {
  // Set the "needs cleanups" bit regardless of whether there are
  // any explicit objects.
  Cleanup.setExprNeedsCleanups(InitWithCleanup->cleanupsHaveSideEffects());
  // Append all the objects to the cleanup list.  Right now, this
  // should always be a no-op, because blocks in default argument
  // expressions should never be able to capture anything.
  assert(!InitWithCleanup->getNumObjects() &&(static_cast <bool> (!InitWithCleanup->getNumObjects
() && "default argument expression has capturing blocks?"
) ? void (0) : __assert_fail ("!InitWithCleanup->getNumObjects() && \"default argument expression has capturing blocks?\""
, "clang/lib/Sema/SemaExpr.cpp", 5917, __extension__ __PRETTY_FUNCTION__
))
         "default argument expression has capturing blocks?")(static_cast <bool> (!InitWithCleanup->getNumObjects
() && "default argument expression has capturing blocks?"
) ? void (0) : __assert_fail ("!InitWithCleanup->getNumObjects() && \"default argument expression has capturing blocks?\""
, "clang/lib/Sema/SemaExpr.cpp", 5917, __extension__ __PRETTY_FUNCTION__
));
}
// C++ [expr.const]p15.1:
//   An expression or conversion is in an immediate function context if it is
//   potentially evaluated and [...] its innermost enclosing non-block scope
//   is a function parameter scope of an immediate function.
EnterExpressionEvaluationContext EvalContext(
    *this,
    FD->isConsteval() ? ExpressionEvaluationContext::ImmediateFunctionContext
                      : ExpressionEvaluationContext::PotentiallyEvaluated,
    Param);
ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
    SkipImmediateInvocations;
runWithSufficientStackSpace(CallLoc, [&] {
  MarkDeclarationsReferencedInExpr(Init, /*SkipLocalVariables=*/true);
});
return false;
5934}

5936struct ImmediateCallVisitor : public RecursiveASTVisitor<ImmediateCallVisitor> {
bool HasImmediateCalls = false;

bool shouldVisitImplicitCode() const { return true; }

bool VisitCallExpr(CallExpr *E) {
  if (const FunctionDecl *FD = E->getDirectCallee())
    HasImmediateCalls |= FD->isConsteval();
  return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
}

// SourceLocExpr are not immediate invocations
// but CXXDefaultInitExpr/CXXDefaultArgExpr containing a SourceLocExpr
// need to be rebuilt so that they refer to the correct SourceLocation and
// DeclContext.
bool VisitSourceLocExpr(SourceLocExpr *E) {
  HasImmediateCalls = true;
  return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
}

// A nested lambda might have parameters with immediate invocations
// in their default arguments.
// The compound statement is not visited (as it does not constitute a
// subexpression).
// FIXME: We should consider visiting and transforming captures
// with init expressions.
bool VisitLambdaExpr(LambdaExpr *E) {
  return VisitCXXMethodDecl(E->getCallOperator());
}

// Blocks don't support default parameters, and, as for lambdas,
// we don't consider their body a subexpression.
bool VisitBlockDecl(BlockDecl *B) { return false; }

bool VisitCompoundStmt(CompoundStmt *B) { return false; }

bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
  return TraverseStmt(E->getExpr());
}

bool VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
  return TraverseStmt(E->getExpr());
}
5979};

5981struct EnsureImmediateInvocationInDefaultArgs
  : TreeTransform<EnsureImmediateInvocationInDefaultArgs> {
EnsureImmediateInvocationInDefaultArgs(Sema &SemaRef)
    : TreeTransform(SemaRef) {}

// Lambda can only have immediate invocations in the default
// args of their parameters, which is transformed upon calling the closure.
// The body is not a subexpression, so we have nothing to do.
// FIXME: Immediate calls in capture initializers should be transformed.
ExprResult TransformLambdaExpr(LambdaExpr *E) { return E; }
ExprResult TransformBlockExpr(BlockExpr *E) { return E; }

// Make sure we don't rebuild the this pointer as it would
// cause it to incorrectly point it to the outermost class
// in the case of nested struct initialization.
ExprResult TransformCXXThisExpr(CXXThisExpr *E) { return E; }
5997};

5999ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
                                      FunctionDecl *FD, ParmVarDecl *Param,
                                      Expr *Init) {
assert(Param->hasDefaultArg() && "can't build nonexistent default arg")(static_cast <bool> (Param->hasDefaultArg() &&
 "can't build nonexistent default arg") ? void (0) : __assert_fail
 ("Param->hasDefaultArg() && \"can't build nonexistent default arg\""
, "clang/lib/Sema/SemaExpr.cpp", 6002, __extension__ __PRETTY_FUNCTION__
));

bool NestedDefaultChecking = isCheckingDefaultArgumentOrInitializer();

std::optional<ExpressionEvaluationContextRecord::InitializationContext>
    InitializationContext =
        OutermostDeclarationWithDelayedImmediateInvocations();
if (!InitializationContext.has_value())
  InitializationContext.emplace(CallLoc, Param, CurContext);

if (!Init && !Param->hasUnparsedDefaultArg()) {
  // Mark that we are replacing a default argument first.
  // If we are instantiating a template we won't have to
  // retransform immediate calls.
  // C++ [expr.const]p15.1:
  //   An expression or conversion is in an immediate function context if it
  //   is potentially evaluated and [...] its innermost enclosing non-block
  //   scope is a function parameter scope of an immediate function.
  EnterExpressionEvaluationContext EvalContext(
      *this,
      FD->isConsteval()
          ? ExpressionEvaluationContext::ImmediateFunctionContext
          : ExpressionEvaluationContext::PotentiallyEvaluated,
      Param);

  if (Param->hasUninstantiatedDefaultArg()) {
    if (InstantiateDefaultArgument(CallLoc, FD, Param))
      return ExprError();
  }
  // CWG2631
  // An immediate invocation that is not evaluated where it appears is
  // evaluated and checked for whether it is a constant expression at the
  // point where the enclosing initializer is used in a function call.
  ImmediateCallVisitor V;
  if (!NestedDefaultChecking)
    V.TraverseDecl(Param);
  if (V.HasImmediateCalls) {
    ExprEvalContexts.back().DelayedDefaultInitializationContext = {
        CallLoc, Param, CurContext};
    EnsureImmediateInvocationInDefaultArgs Immediate(*this);
    ExprResult Res;
    runWithSufficientStackSpace(CallLoc, [&] {
      Res = Immediate.TransformInitializer(Param->getInit(),
                                           /*NotCopy=*/false);
    });
    if (Res.isInvalid())
      return ExprError();
    Res = ConvertParamDefaultArgument(Param, Res.get(),
                                      Res.get()->getBeginLoc());
    if (Res.isInvalid())
      return ExprError();
    Init = Res.get();
  }
}

if (CheckCXXDefaultArgExpr(
        CallLoc, FD, Param, Init,
        /*SkipImmediateInvocations=*/NestedDefaultChecking))
  return ExprError();

return CXXDefaultArgExpr::Create(Context, InitializationContext->Loc, Param,
                                 Init, InitializationContext->Context);
6064}

6066ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
assert(Field->hasInClassInitializer())(static_cast <bool> (Field->hasInClassInitializer())
 ? void (0) : __assert_fail ("Field->hasInClassInitializer()"
, "clang/lib/Sema/SemaExpr.cpp", 6067, __extension__ __PRETTY_FUNCTION__
));

// If we might have already tried and failed to instantiate, don't try again.
if (Field->isInvalidDecl())
  return ExprError();

auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());

std::optional<ExpressionEvaluationContextRecord::InitializationContext>
    InitializationContext =
        OutermostDeclarationWithDelayedImmediateInvocations();
if (!InitializationContext.has_value())
  InitializationContext.emplace(Loc, Field, CurContext);

Expr *Init = nullptr;

bool NestedDefaultChecking = isCheckingDefaultArgumentOrInitializer();

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

if (!Field->getInClassInitializer()) {
  // Maybe we haven't instantiated the in-class initializer. Go check the
  // pattern FieldDecl to see if it has one.
  if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
    CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
    DeclContext::lookup_result Lookup =
        ClassPattern->lookup(Field->getDeclName());

    FieldDecl *Pattern = nullptr;
    for (auto *L : Lookup) {
      if ((Pattern = dyn_cast<FieldDecl>(L)))
        break;
    }
    assert(Pattern && "We must have set the Pattern!")(static_cast <bool> (Pattern && "We must have set the Pattern!"
) ? void (0) : __assert_fail ("Pattern && \"We must have set the Pattern!\""
, "clang/lib/Sema/SemaExpr.cpp", 6101, __extension__ __PRETTY_FUNCTION__
));
    if (!Pattern->hasInClassInitializer() ||
        InstantiateInClassInitializer(Loc, Field, Pattern,
                                      getTemplateInstantiationArgs(Field))) {
      Field->setInvalidDecl();
      return ExprError();
    }
  }
}

// CWG2631
// An immediate invocation that is not evaluated where it appears is
// evaluated and checked for whether it is a constant expression at the
// point where the enclosing initializer is used in a [...] a constructor
// definition, or an aggregate initialization.
ImmediateCallVisitor V;
if (!NestedDefaultChecking)
  V.TraverseDecl(Field);
if (V.HasImmediateCalls) {
  ExprEvalContexts.back().DelayedDefaultInitializationContext = {Loc, Field,
                                                                 CurContext};
  ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
      NestedDefaultChecking;

  EnsureImmediateInvocationInDefaultArgs Immediate(*this);
  ExprResult Res;
  runWithSufficientStackSpace(Loc, [&] {
    Res = Immediate.TransformInitializer(Field->getInClassInitializer(),
                                         /*CXXDirectInit=*/false);
  });
  if (!Res.isInvalid())
    Res = ConvertMemberDefaultInitExpression(Field, Res.get(), Loc);
  if (Res.isInvalid()) {
    Field->setInvalidDecl();
    return ExprError();
  }
  Init = Res.get();
}

if (Field->getInClassInitializer()) {
  Expr *E = Init ? Init : Field->getInClassInitializer();
  if (!NestedDefaultChecking)
    runWithSufficientStackSpace(Loc, [&] {
      MarkDeclarationsReferencedInExpr(E, /*SkipLocalVariables=*/false);
    });
  // C++11 [class.base.init]p7:
  //   The initialization of each base and member constitutes a
  //   full-expression.
  ExprResult Res = ActOnFinishFullExpr(E, /*DiscardedValue=*/false);
  if (Res.isInvalid()) {
    Field->setInvalidDecl();
    return ExprError();
  }
  Init = Res.get();

  return CXXDefaultInitExpr::Create(Context, InitializationContext->Loc,
                                    Field, InitializationContext->Context,
                                    Init);
}

// DR1351:
//   If the brace-or-equal-initializer of a non-static data member
//   invokes a defaulted default constructor of its class or of an
//   enclosing class in a potentially evaluated subexpression, the
//   program is ill-formed.
//
// This resolution is unworkable: the exception specification of the
// default constructor can be needed in an unevaluated context, in
// particular, in the operand of a noexcept-expression, and we can be
// unable to compute an exception specification for an enclosed class.
//
// Any attempt to resolve the exception specification of a defaulted default
// constructor before the initializer is lexically complete will ultimately
// come here at which point we can diagnose it.
RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
Diag(Loc, diag::err_default_member_initializer_not_yet_parsed)
    << OutermostClass << Field;
Diag(Field->getEndLoc(),
     diag::note_default_member_initializer_not_yet_parsed);
// Recover by marking the field invalid, unless we're in a SFINAE context.
if (!isSFINAEContext())
  Field->setInvalidDecl();
return ExprError();
6184}

6186Sema::VariadicCallType
6187Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto,
                        Expr *Fn) {
if (Proto && Proto->isVariadic()) {
  if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
    return VariadicConstructor;
  else if (Fn && Fn->getType()->isBlockPointerType())
    return VariadicBlock;
  else if (FDecl) {
    if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
      if (Method->isInstance())
        return VariadicMethod;
  } else if (Fn && Fn->getType() == Context.BoundMemberTy)
    return VariadicMethod;
  return VariadicFunction;
}
return VariadicDoesNotApply;
6203}

6205namespace {
6206class FunctionCallCCC final : public FunctionCallFilterCCC {
6207public:
FunctionCallCCC(Sema &SemaRef, const IdentifierInfo *FuncName,
                unsigned NumArgs, MemberExpr *ME)
    : FunctionCallFilterCCC(SemaRef, NumArgs, false, ME),
      FunctionName(FuncName) {}

bool ValidateCandidate(const TypoCorrection &candidate) override {
  if (!candidate.getCorrectionSpecifier() ||
      candidate.getCorrectionAsIdentifierInfo() != FunctionName) {
    return false;
  }

  return FunctionCallFilterCCC::ValidateCandidate(candidate);
}

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

6226private:
const IdentifierInfo *const FunctionName;
6228};
6229}

6231static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn,
                                             FunctionDecl *FDecl,
                                             ArrayRef<Expr *> Args) {
MemberExpr *ME = dyn_cast<MemberExpr>(Fn);
DeclarationName FuncName = FDecl->getDeclName();
SourceLocation NameLoc = ME ? ME->getMemberLoc() : Fn->getBeginLoc();

FunctionCallCCC CCC(S, FuncName.getAsIdentifierInfo(), Args.size(), ME);
if (TypoCorrection Corrected = S.CorrectTypo(
        DeclarationNameInfo(FuncName, NameLoc), Sema::LookupOrdinaryName,
        S.getScopeForContext(S.CurContext), nullptr, CCC,
        Sema::CTK_ErrorRecovery)) {
  if (NamedDecl *ND = Corrected.getFoundDecl()) {
    if (Corrected.isOverloaded()) {
      OverloadCandidateSet OCS(NameLoc, OverloadCandidateSet::CSK_Normal);
      OverloadCandidateSet::iterator Best;
      for (NamedDecl *CD : Corrected) {
        if (FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
          S.AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args,
                                 OCS);
      }
      switch (OCS.BestViableFunction(S, NameLoc, Best)) {
      case OR_Success:
        ND = Best->FoundDecl;
        Corrected.setCorrectionDecl(ND);
        break;
      default:
        break;
      }
    }
    ND = ND->getUnderlyingDecl();
    if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
      return Corrected;
  }
}
return TypoCorrection();
6267}

6269/// ConvertArgumentsForCall - Converts the arguments specified in
6270/// Args/NumArgs to the parameter types of the function FDecl with
6271/// function prototype Proto. Call is the call expression itself, and
6272/// Fn is the function expression. For a C++ member function, this
6273/// routine does not attempt to convert the object argument. Returns
6274/// true if the call is ill-formed.
6275bool
6276Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
                            FunctionDecl *FDecl,
                            const FunctionProtoType *Proto,
                            ArrayRef<Expr *> Args,
                            SourceLocation RParenLoc,
                            bool IsExecConfig) {
// Bail out early if calling a builtin with custom typechecking.
if (FDecl)
  if (unsigned ID = FDecl->getBuiltinID())
    if (Context.BuiltinInfo.hasCustomTypechecking(ID))
      return false;

// C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
// assignment, to the types of the corresponding parameter, ...
unsigned NumParams = Proto->getNumParams();
bool Invalid = false;
unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams;
unsigned FnKind = Fn->getType()->isBlockPointerType()
                     ? 1 /* block */
                     : (IsExecConfig ? 3 /* kernel function (exec config) */
                                     : 0 /* function */);

// If too few arguments are available (and we don't have default
// arguments for the remaining parameters), don't make the call.
if (Args.size() < NumParams) {
  if (Args.size() < MinArgs) {
    TypoCorrection TC;
    if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
      unsigned diag_id =
          MinArgs == NumParams && !Proto->isVariadic()
              ? diag::err_typecheck_call_too_few_args_suggest
              : diag::err_typecheck_call_too_few_args_at_least_suggest;
      diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs
                                      << static_cast<unsigned>(Args.size())
                                      << TC.getCorrectionRange());
    } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName())
      Diag(RParenLoc,
           MinArgs == NumParams && !Proto->isVariadic()
               ? diag::err_typecheck_call_too_few_args_one
               : diag::err_typecheck_call_too_few_args_at_least_one)
          << FnKind << FDecl->getParamDecl(0) << Fn->getSourceRange();
    else
      Diag(RParenLoc, MinArgs == NumParams && !Proto->isVariadic()
                          ? diag::err_typecheck_call_too_few_args
                          : diag::err_typecheck_call_too_few_args_at_least)
          << FnKind << MinArgs << static_cast<unsigned>(Args.size())
          << Fn->getSourceRange();

    // Emit the location of the prototype.
    if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
      Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl;

    return true;
  }
  // We reserve space for the default arguments when we create
  // the call expression, before calling ConvertArgumentsForCall.
  assert((Call->getNumArgs() == NumParams) &&(static_cast <bool> ((Call->getNumArgs() == NumParams
) && "We should have reserved space for the default arguments before!"
) ? void (0) : __assert_fail ("(Call->getNumArgs() == NumParams) && \"We should have reserved space for the default arguments before!\""
, "clang/lib/Sema/SemaExpr.cpp", 6333, __extension__ __PRETTY_FUNCTION__
))
         "We should have reserved space for the default arguments before!")(static_cast <bool> ((Call->getNumArgs() == NumParams
) && "We should have reserved space for the default arguments before!"
) ? void (0) : __assert_fail ("(Call->getNumArgs() == NumParams) && \"We should have reserved space for the default arguments before!\""
, "clang/lib/Sema/SemaExpr.cpp", 6333, __extension__ __PRETTY_FUNCTION__
));
}

// If too many are passed and not variadic, error on the extras and drop
// them.
if (Args.size() > NumParams) {
  if (!Proto->isVariadic()) {
    TypoCorrection TC;
    if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
      unsigned diag_id =
          MinArgs == NumParams && !Proto->isVariadic()
              ? diag::err_typecheck_call_too_many_args_suggest
              : diag::err_typecheck_call_too_many_args_at_most_suggest;
      diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumParams
                                      << static_cast<unsigned>(Args.size())
                                      << TC.getCorrectionRange());
    } else if (NumParams == 1 && FDecl &&
               FDecl->getParamDecl(0)->getDeclName())
      Diag(Args[NumParams]->getBeginLoc(),
           MinArgs == NumParams
               ? diag::err_typecheck_call_too_many_args_one
               : diag::err_typecheck_call_too_many_args_at_most_one)
          << FnKind << FDecl->getParamDecl(0)
          << static_cast<unsigned>(Args.size()) << Fn->getSourceRange()
          << SourceRange(Args[NumParams]->getBeginLoc(),
                         Args.back()->getEndLoc());
    else
      Diag(Args[NumParams]->getBeginLoc(),
           MinArgs == NumParams
               ? diag::err_typecheck_call_too_many_args
               : diag::err_typecheck_call_too_many_args_at_most)
          << FnKind << NumParams << static_cast<unsigned>(Args.size())
          << Fn->getSourceRange()
          << SourceRange(Args[NumParams]->getBeginLoc(),
                         Args.back()->getEndLoc());

    // Emit the location of the prototype.
    if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
      Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl;

    // This deletes the extra arguments.
    Call->shrinkNumArgs(NumParams);
    return true;
  }
}
SmallVector<Expr *, 8> AllArgs;
VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn);

Invalid = GatherArgumentsForCall(Call->getBeginLoc(), FDecl, Proto, 0, Args,
                                 AllArgs, CallType);
if (Invalid)
  return true;
unsigned TotalNumArgs = AllArgs.size();
for (unsigned i = 0; i < TotalNumArgs; ++i)
  Call->setArg(i, AllArgs[i]);

Call->computeDependence();
return false;
6391}

6393bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
                                const FunctionProtoType *Proto,
                                unsigned FirstParam, ArrayRef<Expr *> Args,
                                SmallVectorImpl<Expr *> &AllArgs,
                                VariadicCallType CallType, bool AllowExplicit,
                                bool IsListInitialization) {
unsigned NumParams = Proto->getNumParams();
bool Invalid = false;
size_t ArgIx = 0;
// Continue to check argument types (even if we have too few/many args).
for (unsigned i = FirstParam; i < NumParams; i++) {
  QualType ProtoArgType = Proto->getParamType(i);

  Expr *Arg;
  ParmVarDecl *Param = FDecl ? FDecl->getParamDecl(i) : nullptr;
  if (ArgIx < Args.size()) {
    Arg = Args[ArgIx++];

    if (RequireCompleteType(Arg->getBeginLoc(), ProtoArgType,
                            diag::err_call_incomplete_argument, Arg))
      return true;

    // Strip the unbridged-cast placeholder expression off, if applicable.
    bool CFAudited = false;
    if (Arg->getType() == Context.ARCUnbridgedCastTy &&
        FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
        (!Param || !Param->hasAttr<CFConsumedAttr>()))
      Arg = stripARCUnbridgedCast(Arg);
    else if (getLangOpts().ObjCAutoRefCount &&
             FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
             (!Param || !Param->hasAttr<CFConsumedAttr>()))
      CFAudited = true;

    if (Proto->getExtParameterInfo(i).isNoEscape() &&
        ProtoArgType->isBlockPointerType())
      if (auto *BE = dyn_cast<BlockExpr>(Arg->IgnoreParenNoopCasts(Context)))
        BE->getBlockDecl()->setDoesNotEscape();

    InitializedEntity Entity =
        Param ? InitializedEntity::InitializeParameter(Context, Param,
                                                       ProtoArgType)
              : InitializedEntity::InitializeParameter(
                    Context, ProtoArgType, Proto->isParamConsumed(i));

    // Remember that parameter belongs to a CF audited API.
    if (CFAudited)
      Entity.setParameterCFAudited();

    ExprResult ArgE = PerformCopyInitialization(
        Entity, SourceLocation(), Arg, IsListInitialization, AllowExplicit);
    if (ArgE.isInvalid())
      return true;

    Arg = ArgE.getAs<Expr>();
  } else {
    assert(Param && "can't use default arguments without a known callee")(static_cast <bool> (Param && "can't use default arguments without a known callee"
) ? void (0) : __assert_fail ("Param && \"can't use default arguments without a known callee\""
, "clang/lib/Sema/SemaExpr.cpp", 6448, __extension__ __PRETTY_FUNCTION__
));

    ExprResult ArgExpr = BuildCXXDefaultArgExpr(CallLoc, FDecl, Param);
    if (ArgExpr.isInvalid())
      return true;

    Arg = ArgExpr.getAs<Expr>();
  }

  // Check for array bounds violations for each argument to the call. This
  // check only triggers warnings when the argument isn't a more complex Expr
  // with its own checking, such as a BinaryOperator.
  CheckArrayAccess(Arg);

  // Check for violations of C99 static array rules (C99 6.7.5.3p7).
  CheckStaticArrayArgument(CallLoc, Param, Arg);

  AllArgs.push_back(Arg);
}

// If this is a variadic call, handle args passed through "...".
if (CallType != VariadicDoesNotApply) {
  // Assume that extern "C" functions with variadic arguments that
  // return __unknown_anytype aren't *really* variadic.
  if (Proto->getReturnType() == Context.UnknownAnyTy && FDecl &&
      FDecl->isExternC()) {
    for (Expr *A : Args.slice(ArgIx)) {
      QualType paramType; // ignored
      ExprResult arg = checkUnknownAnyArg(CallLoc, A, paramType);
      Invalid |= arg.isInvalid();
      AllArgs.push_back(arg.get());
    }

  // Otherwise do argument promotion, (C99 6.5.2.2p7).
  } else {
    for (Expr *A : Args.slice(ArgIx)) {
      ExprResult Arg = DefaultVariadicArgumentPromotion(A, CallType, FDecl);
      Invalid |= Arg.isInvalid();
      AllArgs.push_back(Arg.get());
    }
  }

  // Check for array bounds violations.
  for (Expr *A : Args.slice(ArgIx))
    CheckArrayAccess(A);
}
return Invalid;
6495}

6497static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) {
TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc();
if (DecayedTypeLoc DTL = TL.getAs<DecayedTypeLoc>())
  TL = DTL.getOriginalLoc();
if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())
  S.Diag(PVD->getLocation(), diag::note_callee_static_array)
    << ATL.getLocalSourceRange();
6504}

6506/// CheckStaticArrayArgument - If the given argument corresponds to a static
6507/// array parameter, check that it is non-null, and that if it is formed by
6508/// array-to-pointer decay, the underlying array is sufficiently large.
6509///
6510/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the
6511/// array type derivation, then for each call to the function, the value of the
6512/// corresponding actual argument shall provide access to the first element of
6513/// an array with at least as many elements as specified by the size expression.
6514void
6515Sema::CheckStaticArrayArgument(SourceLocation CallLoc,
                             ParmVarDecl *Param,
                             const Expr *ArgExpr) {
// Static array parameters are not supported in C++.
if (!Param || getLangOpts().CPlusPlus)
  return;

QualType OrigTy = Param->getOriginalType();

const ArrayType *AT = Context.getAsArrayType(OrigTy);
if (!AT || AT->getSizeModifier() != ArrayType::Static)
  return;

if (ArgExpr->isNullPointerConstant(Context,
                                   Expr::NPC_NeverValueDependent)) {
  Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();
  DiagnoseCalleeStaticArrayParam(*this, Param);
  return;
}

const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT);
if (!CAT)
  return;

const ConstantArrayType *ArgCAT =
  Context.getAsConstantArrayType(ArgExpr->IgnoreParenCasts()->getType());
if (!ArgCAT)
  return;

if (getASTContext().hasSameUnqualifiedType(CAT->getElementType(),
                                           ArgCAT->getElementType())) {
  if (ArgCAT->getSize().ult(CAT->getSize())) {
    Diag(CallLoc, diag::warn_static_array_too_small)
        << ArgExpr->getSourceRange()
        << (unsigned)ArgCAT->getSize().getZExtValue()
        << (unsigned)CAT->getSize().getZExtValue() << 0;
    DiagnoseCalleeStaticArrayParam(*this, Param);
  }
  return;
}

std::optional<CharUnits> ArgSize =
    getASTContext().getTypeSizeInCharsIfKnown(ArgCAT);
std::optional<CharUnits> ParmSize =
    getASTContext().getTypeSizeInCharsIfKnown(CAT);
if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
  Diag(CallLoc, diag::warn_static_array_too_small)
      << ArgExpr->getSourceRange() << (unsigned)ArgSize->getQuantity()
      << (unsigned)ParmSize->getQuantity() << 1;
  DiagnoseCalleeStaticArrayParam(*this, Param);
}
6566}

6568/// Given a function expression of unknown-any type, try to rebuild it
6569/// to have a function type.
6570static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn);

6572/// Is the given type a placeholder that we need to lower out
6573/// immediately during argument processing?
6574static bool isPlaceholderToRemoveAsArg(QualType type) {
// Placeholders are never sugared.
const BuiltinType *placeholder = dyn_cast<BuiltinType>(type);
if (!placeholder) return false;

switch (placeholder->getKind()) {
// Ignore all the non-placeholder types.
6581#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
6583#include "clang/Basic/OpenCLImageTypes.def"
6584#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
6586#include "clang/Basic/OpenCLExtensionTypes.def"
// In practice we'll never use this, since all SVE types are sugared
// via TypedefTypes rather than exposed directly as BuiltinTypes.
6589#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
6591#include "clang/Basic/AArch64SVEACLETypes.def"
6592#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id:
6594#include "clang/Basic/PPCTypes.def"
6595#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6596#include "clang/Basic/RISCVVTypes.def"
6597#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6598#include "clang/Basic/WebAssemblyReferenceTypes.def"
6599#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6600#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6601#include "clang/AST/BuiltinTypes.def"
  return false;

// We cannot lower out overload sets; they might validly be resolved
// by the call machinery.
case BuiltinType::Overload:
  return false;

// Unbridged casts in ARC can be handled in some call positions and
// should be left in place.
case BuiltinType::ARCUnbridgedCast:
  return false;

// Pseudo-objects should be converted as soon as possible.
case BuiltinType::PseudoObject:
  return true;

// The debugger mode could theoretically but currently does not try
// to resolve unknown-typed arguments based on known parameter types.
case BuiltinType::UnknownAny:
  return true;

// These are always invalid as call arguments and should be reported.
case BuiltinType::BoundMember:
case BuiltinType::BuiltinFn:
case BuiltinType::IncompleteMatrixIdx:
case BuiltinType::OMPArraySection:
case BuiltinType::OMPArrayShaping:
case BuiltinType::OMPIterator:
  return true;

}
llvm_unreachable("bad builtin type kind")::llvm::llvm_unreachable_internal("bad builtin type kind", "clang/lib/Sema/SemaExpr.cpp"
, 6633);
6634}

6636/// Check an argument list for placeholders that we won't try to
6637/// handle later.
6638static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args) {
// Apply this processing to all the arguments at once instead of
// dying at the first failure.
bool hasInvalid = false;
for (size_t i = 0, e = args.size(); i != e; i++) {
  if (isPlaceholderToRemoveAsArg(args[i]->getType())) {
    ExprResult result = S.CheckPlaceholderExpr(args[i]);
    if (result.isInvalid()) hasInvalid = true;
    else args[i] = result.get();
  }
}
return hasInvalid;
6650}

6652/// If a builtin function has a pointer argument with no explicit address
6653/// space, then it should be able to accept a pointer to any address
6654/// space as input.  In order to do this, we need to replace the
6655/// standard builtin declaration with one that uses the same address space
6656/// as the call.
6657///
6658/// \returns nullptr If this builtin is not a candidate for a rewrite i.e.
6659///                  it does not contain any pointer arguments without
6660///                  an address space qualifer.  Otherwise the rewritten
6661///                  FunctionDecl is returned.
6662/// TODO: Handle pointer return types.
6663static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
                                              FunctionDecl *FDecl,
                                              MultiExprArg ArgExprs) {

QualType DeclType = FDecl->getType();
const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(DeclType);

if (!Context.BuiltinInfo.hasPtrArgsOrResult(FDecl->getBuiltinID()) || !FT ||
    ArgExprs.size() < FT->getNumParams())
  return nullptr;

bool NeedsNewDecl = false;
unsigned i = 0;
SmallVector<QualType, 8> OverloadParams;

for (QualType ParamType : FT->param_types()) {

  // Convert array arguments to pointer to simplify type lookup.
  ExprResult ArgRes =
      Sema->DefaultFunctionArrayLvalueConversion(ArgExprs[i++]);
  if (ArgRes.isInvalid())
    return nullptr;
  Expr *Arg = ArgRes.get();
  QualType ArgType = Arg->getType();
  if (!ParamType->isPointerType() || ParamType.hasAddressSpace() ||
      !ArgType->isPointerType() ||
      !ArgType->getPointeeType().hasAddressSpace() ||
      isPtrSizeAddressSpace(ArgType->getPointeeType().getAddressSpace())) {
    OverloadParams.push_back(ParamType);
    continue;
  }

  QualType PointeeType = ParamType->getPointeeType();
  if (PointeeType.hasAddressSpace())
    continue;

  NeedsNewDecl = true;
  LangAS AS = ArgType->getPointeeType().getAddressSpace();

  PointeeType = Context.getAddrSpaceQualType(PointeeType, AS);
  OverloadParams.push_back(Context.getPointerType(PointeeType));
}

if (!NeedsNewDecl)
  return nullptr;

FunctionProtoType::ExtProtoInfo EPI;
EPI.Variadic = FT->isVariadic();
QualType OverloadTy = Context.getFunctionType(FT->getReturnType(),
                                              OverloadParams, EPI);
DeclContext *Parent = FDecl->getParent();
FunctionDecl *OverloadDecl = FunctionDecl::Create(
    Context, Parent, FDecl->getLocation(), FDecl->getLocation(),
    FDecl->getIdentifier(), OverloadTy,
    /*TInfo=*/nullptr, SC_Extern, Sema->getCurFPFeatures().isFPConstrained(),
    false,
    /*hasPrototype=*/true);
SmallVector<ParmVarDecl*, 16> Params;
FT = cast<FunctionProtoType>(OverloadTy);
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
  QualType ParamType = FT->getParamType(i);
  ParmVarDecl *Parm =
      ParmVarDecl::Create(Context, OverloadDecl, SourceLocation(),
                              SourceLocation(), nullptr, ParamType,
                              /*TInfo=*/nullptr, SC_None, nullptr);
  Parm->setScopeInfo(0, i);
  Params.push_back(Parm);
}
OverloadDecl->setParams(Params);
Sema->mergeDeclAttributes(OverloadDecl, FDecl);
return OverloadDecl;
6734}

6736static void checkDirectCallValidity(Sema &S, const Expr *Fn,
                                  FunctionDecl *Callee,
                                  MultiExprArg ArgExprs) {
// `Callee` (when called with ArgExprs) may be ill-formed. enable_if (and
// similar attributes) really don't like it when functions are called with an
// invalid number of args.
if (S.TooManyArguments(Callee->getNumParams(), ArgExprs.size(),
                       /*PartialOverloading=*/false) &&
    !Callee->isVariadic())
  return;
if (Callee->getMinRequiredArguments() > ArgExprs.size())
  return;

if (const EnableIfAttr *Attr =
        S.CheckEnableIf(Callee, Fn->getBeginLoc(), ArgExprs, true)) {
  S.Diag(Fn->getBeginLoc(),
         isa<CXXMethodDecl>(Callee)
             ? diag::err_ovl_no_viable_member_function_in_call
             : diag::err_ovl_no_viable_function_in_call)
      << Callee << Callee->getSourceRange();
  S.Diag(Callee->getLocation(),
         diag::note_ovl_candidate_disabled_by_function_cond_attr)
      << Attr->getCond()->getSourceRange() << Attr->getMessage();
  return;
}
6761}

6763static bool enclosingClassIsRelatedToClassInWhichMembersWereFound(
  const UnresolvedMemberExpr *const UME, Sema &S) {

const auto GetFunctionLevelDCIfCXXClass =
    [](Sema &S) -> const CXXRecordDecl * {
  const DeclContext *const DC = S.getFunctionLevelDeclContext();
  if (!DC || !DC->getParent())
    return nullptr;

  // If the call to some member function was made from within a member
  // function body 'M' return return 'M's parent.
  if (const auto *MD = dyn_cast<CXXMethodDecl>(DC))
    return MD->getParent()->getCanonicalDecl();
  // else the call was made from within a default member initializer of a
  // class, so return the class.
  if (const auto *RD = dyn_cast<CXXRecordDecl>(DC))
    return RD->getCanonicalDecl();
  return nullptr;
};
// If our DeclContext is neither a member function nor a class (in the
// case of a lambda in a default member initializer), we can't have an
// enclosing 'this'.

const CXXRecordDecl *const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
if (!CurParentClass)
  return false;

// The naming class for implicit member functions call is the class in which
// name lookup starts.
const CXXRecordDecl *const NamingClass =
    UME->getNamingClass()->getCanonicalDecl();
assert(NamingClass && "Must have naming class even for implicit access")(static_cast <bool> (NamingClass && "Must have naming class even for implicit access"
) ? void (0) : __assert_fail ("NamingClass && \"Must have naming class even for implicit access\""
, "clang/lib/Sema/SemaExpr.cpp", 6794, __extension__ __PRETTY_FUNCTION__
));

// If the unresolved member functions were found in a 'naming class' that is
// related (either the same or derived from) to the class that contains the
// member function that itself contained the implicit member access.

return CurParentClass == NamingClass ||
       CurParentClass->isDerivedFrom(NamingClass);
6802}

6804static void
6805tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
  Sema &S, const UnresolvedMemberExpr *const UME, SourceLocation CallLoc) {

if (!UME)
  return;

LambdaScopeInfo *const CurLSI = S.getCurLambda();
// Only try and implicitly capture 'this' within a C++ Lambda if it hasn't
// already been captured, or if this is an implicit member function call (if
// it isn't, an attempt to capture 'this' should already have been made).
if (!CurLSI || CurLSI->ImpCaptureStyle == CurLSI->ImpCap_None ||
    !UME->isImplicitAccess() || CurLSI->isCXXThisCaptured())
  return;

// Check if the naming class in which the unresolved members were found is
// related (same as or is a base of) to the enclosing class.

if (!enclosingClassIsRelatedToClassInWhichMembersWereFound(UME, S))
  return;


DeclContext *EnclosingFunctionCtx = S.CurContext->getParent()->getParent();
// If the enclosing function is not dependent, then this lambda is
// capture ready, so if we can capture this, do so.
if (!EnclosingFunctionCtx->isDependentContext()) {
  // If the current lambda and all enclosing lambdas can capture 'this' -
  // then go ahead and capture 'this' (since our unresolved overload set
  // contains at least one non-static member function).
  if (!S.CheckCXXThisCapture(CallLoc, /*Explcit*/ false, /*Diagnose*/ false))
    S.CheckCXXThisCapture(CallLoc);
} else if (S.CurContext->isDependentContext()) {
  // ... since this is an implicit member reference, that might potentially
  // involve a 'this' capture, mark 'this' for potential capture in
  // enclosing lambdas.
  if (CurLSI->ImpCaptureStyle != CurLSI->ImpCap_None)
    CurLSI->addPotentialThisCapture(CallLoc);
}
6842}

6844// Once a call is fully resolved, warn for unqualified calls to specific
6845// C++ standard functions, like move and forward.
6846static void DiagnosedUnqualifiedCallsToStdFunctions(Sema &S, CallExpr *Call) {
// We are only checking unary move and forward so exit early here.
if (Call->getNumArgs() != 1)
  return;

Expr *E = Call->getCallee()->IgnoreParenImpCasts();
if (!E || isa<UnresolvedLookupExpr>(E))
  return;
DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E);
if (!DRE || !DRE->getLocation().isValid())
  return;

if (DRE->getQualifier())
  return;

const FunctionDecl *FD = Call->getDirectCallee();
if (!FD)
  return;

// Only warn for some functions deemed more frequent or problematic.
unsigned BuiltinID = FD->getBuiltinID();
if (BuiltinID != Builtin::BImove && BuiltinID != Builtin::BIforward)
  return;

S.Diag(DRE->getLocation(), diag::warn_unqualified_call_to_std_cast_function)
    << FD->getQualifiedNameAsString()
    << FixItHint::CreateInsertion(DRE->getLocation(), "std::");
6873}

6875ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                             MultiExprArg ArgExprs, SourceLocation RParenLoc,
                             Expr *ExecConfig) {
ExprResult Call =
    BuildCallExpr(Scope, Fn, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
                  /*IsExecConfig=*/false, /*AllowRecovery=*/true);
if (Call.isInvalid())
  return Call;

// Diagnose uses of the C++20 "ADL-only template-id call" feature in earlier
// language modes.
if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) {
  if (ULE->hasExplicitTemplateArgs() &&
      ULE->decls_begin() == ULE->decls_end()) {
    Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus20
                               ? diag::warn_cxx17_compat_adl_only_template_id
                               : diag::ext_adl_only_template_id)
        << ULE->getName();
  }
}

if (LangOpts.OpenMP)
  Call = ActOnOpenMPCall(Call, Scope, LParenLoc, ArgExprs, RParenLoc,
                         ExecConfig);
if (LangOpts.CPlusPlus) {
  CallExpr *CE = dyn_cast<CallExpr>(Call.get());
  if (CE)
    DiagnosedUnqualifiedCallsToStdFunctions(*this, CE);
}
return Call;
6905}

6907/// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
6908/// This provides the location of the left/right parens and a list of comma
6909/// locations.
6910ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                             MultiExprArg ArgExprs, SourceLocation RParenLoc,
                             Expr *ExecConfig, bool IsExecConfig,
                             bool AllowRecovery) {
// Since this might be a postfix expression, get rid of ParenListExprs.
ExprResult Result = MaybeConvertParenListExprToParenExpr(Scope, Fn);
if (Result.isInvalid()) return ExprError();
Fn = Result.get();

if (checkArgsForPlaceholders(*this, ArgExprs))
  return ExprError();

if (getLangOpts().CPlusPlus) {
  // If this is a pseudo-destructor expression, build the call immediately.
  if (isa<CXXPseudoDestructorExpr>(Fn)) {
    if (!ArgExprs.empty()) {
      // Pseudo-destructor calls should not have any arguments.
      Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args)
          << FixItHint::CreateRemoval(
                 SourceRange(ArgExprs.front()->getBeginLoc(),
                             ArgExprs.back()->getEndLoc()));
    }

    return CallExpr::Create(Context, Fn, /*Args=*/{}, Context.VoidTy,
                            VK_PRValue, RParenLoc, CurFPFeatureOverrides());
  }
  if (Fn->getType() == Context.PseudoObjectTy) {
    ExprResult result = CheckPlaceholderExpr(Fn);
    if (result.isInvalid()) return ExprError();
    Fn = result.get();
  }

  // Determine whether this is a dependent call inside a C++ template,
  // in which case we won't do any semantic analysis now.
  if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
    if (ExecConfig) {
      return CUDAKernelCallExpr::Create(Context, Fn,
                                        cast<CallExpr>(ExecConfig), ArgExprs,
                                        Context.DependentTy, VK_PRValue,
                                        RParenLoc, CurFPFeatureOverrides());
    } else {

      tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
          *this, dyn_cast<UnresolvedMemberExpr>(Fn->IgnoreParens()),
          Fn->getBeginLoc());

      return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
                              VK_PRValue, RParenLoc, CurFPFeatureOverrides());
    }
  }

  // Determine whether this is a call to an object (C++ [over.call.object]).
  if (Fn->getType()->isRecordType())
    return BuildCallToObjectOfClassType(Scope, Fn, LParenLoc, ArgExprs,
                                        RParenLoc);

  if (Fn->getType() == Context.UnknownAnyTy) {
    ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
    if (result.isInvalid()) return ExprError();
    Fn = result.get();
  }

  if (Fn->getType() == Context.BoundMemberTy) {
    return BuildCallToMemberFunction(Scope, Fn, LParenLoc, ArgExprs,
                                     RParenLoc, ExecConfig, IsExecConfig,
                                     AllowRecovery);
  }
}

// Check for overloaded calls.  This can happen even in C due to extensions.
if (Fn->getType() == Context.OverloadTy) {
  OverloadExpr::FindResult find = OverloadExpr::find(Fn);

  // We aren't supposed to apply this logic if there's an '&' involved.
  if (!find.HasFormOfMemberPointer) {
    if (Expr::hasAnyTypeDependentArguments(ArgExprs))
      return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
                              VK_PRValue, RParenLoc, CurFPFeatureOverrides());
    OverloadExpr *ovl = find.Expression;
    if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(ovl))
      return BuildOverloadedCallExpr(
          Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
          /*AllowTypoCorrection=*/true, find.IsAddressOfOperand);
    return BuildCallToMemberFunction(Scope, Fn, LParenLoc, ArgExprs,
                                     RParenLoc, ExecConfig, IsExecConfig,
                                     AllowRecovery);
  }
}

// If we're directly calling a function, get the appropriate declaration.
if (Fn->getType() == Context.UnknownAnyTy) {
  ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
  if (result.isInvalid()) return ExprError();
  Fn = result.get();
}

Expr *NakedFn = Fn->IgnoreParens();

bool CallingNDeclIndirectly = false;
NamedDecl *NDecl = nullptr;
if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
  if (UnOp->getOpcode() == UO_AddrOf) {
    CallingNDeclIndirectly = true;
    NakedFn = UnOp->getSubExpr()->IgnoreParens();
  }
}

if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
  NDecl = DRE->getDecl();

  FunctionDecl *FDecl = dyn_cast<FunctionDecl>(NDecl);
  if (FDecl && FDecl->getBuiltinID()) {
    // Rewrite the function decl for this builtin by replacing parameters
    // with no explicit address space with the address space of the arguments
    // in ArgExprs.
    if ((FDecl =
             rewriteBuiltinFunctionDecl(this, Context, FDecl, ArgExprs))) {
      NDecl = FDecl;
      Fn = DeclRefExpr::Create(
          Context, FDecl->getQualifierLoc(), SourceLocation(), FDecl, false,
          SourceLocation(), FDecl->getType(), Fn->getValueKind(), FDecl,
          nullptr, DRE->isNonOdrUse());
    }
  }
} else if (auto *ME = dyn_cast<MemberExpr>(NakedFn))
  NDecl = ME->getMemberDecl();

if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
  if (CallingNDeclIndirectly && !checkAddressOfFunctionIsAvailable(
                                    FD, /*Complain=*/true, Fn->getBeginLoc()))
    return ExprError();

  checkDirectCallValidity(*this, Fn, FD, ArgExprs);

  // If this expression is a call to a builtin function in HIP device
  // compilation, allow a pointer-type argument to default address space to be
  // passed as a pointer-type parameter to a non-default address space.
  // If Arg is declared in the default address space and Param is declared
  // in a non-default address space, perform an implicit address space cast to
  // the parameter type.
  if (getLangOpts().HIP && getLangOpts().CUDAIsDevice && FD &&
      FD->getBuiltinID()) {
    for (unsigned Idx = 0; Idx < FD->param_size(); ++Idx) {
      ParmVarDecl *Param = FD->getParamDecl(Idx);
      if (!ArgExprs[Idx] || !Param || !Param->getType()->isPointerType() ||
          !ArgExprs[Idx]->getType()->isPointerType())
        continue;

      auto ParamAS = Param->getType()->getPointeeType().getAddressSpace();
      auto ArgTy = ArgExprs[Idx]->getType();
      auto ArgPtTy = ArgTy->getPointeeType();
      auto ArgAS = ArgPtTy.getAddressSpace();

      // Add address space cast if target address spaces are different
      bool NeedImplicitASC =
        ParamAS != LangAS::Default &&       // Pointer params in generic AS don't need special handling.
        ( ArgAS == LangAS::Default  ||      // We do allow implicit conversion from generic AS
                                            // or from specific AS which has target AS matching that of Param.
        getASTContext().getTargetAddressSpace(ArgAS) == getASTContext().getTargetAddressSpace(ParamAS));
      if (!NeedImplicitASC)
        continue;

      // First, ensure that the Arg is an RValue.
      if (ArgExprs[Idx]->isGLValue()) {
        ArgExprs[Idx] = ImplicitCastExpr::Create(
            Context, ArgExprs[Idx]->getType(), CK_NoOp, ArgExprs[Idx],
            nullptr, VK_PRValue, FPOptionsOverride());
      }

      // Construct a new arg type with address space of Param
      Qualifiers ArgPtQuals = ArgPtTy.getQualifiers();
      ArgPtQuals.setAddressSpace(ParamAS);
      auto NewArgPtTy =
          Context.getQualifiedType(ArgPtTy.getUnqualifiedType(), ArgPtQuals);
      auto NewArgTy =
          Context.getQualifiedType(Context.getPointerType(NewArgPtTy),
                                   ArgTy.getQualifiers());

      // Finally perform an implicit address space cast
      ArgExprs[Idx] = ImpCastExprToType(ArgExprs[Idx], NewArgTy,
                                        CK_AddressSpaceConversion)
                          .get();
    }
  }
}

if (Context.isDependenceAllowed() &&
    (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs))) {
  assert(!getLangOpts().CPlusPlus)(static_cast <bool> (!getLangOpts().CPlusPlus) ? void (
0) : __assert_fail ("!getLangOpts().CPlusPlus", "clang/lib/Sema/SemaExpr.cpp"
, 7098, __extension__ __PRETTY_FUNCTION__));
  assert((Fn->containsErrors() ||(static_cast <bool> ((Fn->containsErrors() || llvm::
any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors
(); })) && "should only occur in error-recovery path."
) ? void (0) : __assert_fail ("(Fn->containsErrors() || llvm::any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors(); })) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 7102, __extension__ __PRETTY_FUNCTION__
))
          llvm::any_of(ArgExprs,(static_cast <bool> ((Fn->containsErrors() || llvm::
any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors
(); })) && "should only occur in error-recovery path."
) ? void (0) : __assert_fail ("(Fn->containsErrors() || llvm::any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors(); })) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 7102, __extension__ __PRETTY_FUNCTION__
))
                       [](clang::Expr *E) { return E->containsErrors(); })) &&(static_cast <bool> ((Fn->containsErrors() || llvm::
any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors
(); })) && "should only occur in error-recovery path."
) ? void (0) : __assert_fail ("(Fn->containsErrors() || llvm::any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors(); })) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 7102, __extension__ __PRETTY_FUNCTION__
))
         "should only occur in error-recovery path.")(static_cast <bool> ((Fn->containsErrors() || llvm::
any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors
(); })) && "should only occur in error-recovery path."
) ? void (0) : __assert_fail ("(Fn->containsErrors() || llvm::any_of(ArgExprs, [](clang::Expr *E) { return E->containsErrors(); })) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 7102, __extension__ __PRETTY_FUNCTION__
));
  QualType ReturnType =
      llvm::isa_and_nonnull<FunctionDecl>(NDecl)
          ? cast<FunctionDecl>(NDecl)->getCallResultType()
          : Context.DependentTy;
  return CallExpr::Create(Context, Fn, ArgExprs, ReturnType,
                          Expr::getValueKindForType(ReturnType), RParenLoc,
                          CurFPFeatureOverrides());
}
return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
                             ExecConfig, IsExecConfig);
7113}

7115/// BuildBuiltinCallExpr - Create a call to a builtin function specified by Id
7116//  with the specified CallArgs
7117Expr *Sema::BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
                               MultiExprArg CallArgs) {
StringRef Name = Context.BuiltinInfo.getName(Id);
LookupResult R(*this, &Context.Idents.get(Name), Loc,
               Sema::LookupOrdinaryName);
LookupName(R, TUScope, /*AllowBuiltinCreation=*/true);

auto *BuiltInDecl = R.getAsSingle<FunctionDecl>();
assert(BuiltInDecl && "failed to find builtin declaration")(static_cast <bool> (BuiltInDecl && "failed to find builtin declaration"
) ? void (0) : __assert_fail ("BuiltInDecl && \"failed to find builtin declaration\""
, "clang/lib/Sema/SemaExpr.cpp", 7125, __extension__ __PRETTY_FUNCTION__
));

ExprResult DeclRef =
    BuildDeclRefExpr(BuiltInDecl, BuiltInDecl->getType(), VK_LValue, Loc);
assert(DeclRef.isUsable() && "Builtin reference cannot fail")(static_cast <bool> (DeclRef.isUsable() && "Builtin reference cannot fail"
) ? void (0) : __assert_fail ("DeclRef.isUsable() && \"Builtin reference cannot fail\""
, "clang/lib/Sema/SemaExpr.cpp", 7129, __extension__ __PRETTY_FUNCTION__
));

ExprResult Call =
    BuildCallExpr(/*Scope=*/nullptr, DeclRef.get(), Loc, CallArgs, Loc);

assert(!Call.isInvalid() && "Call to builtin cannot fail!")(static_cast <bool> (!Call.isInvalid() && "Call to builtin cannot fail!"
) ? void (0) : __assert_fail ("!Call.isInvalid() && \"Call to builtin cannot fail!\""
, "clang/lib/Sema/SemaExpr.cpp", 7134, __extension__ __PRETTY_FUNCTION__
));
return Call.get();
7136}

7138/// Parse a __builtin_astype expression.
7139///
7140/// __builtin_astype( value, dst type )
7141///
7142ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
                               SourceLocation BuiltinLoc,
                               SourceLocation RParenLoc) {
QualType DstTy = GetTypeFromParser(ParsedDestTy);
return BuildAsTypeExpr(E, DstTy, BuiltinLoc, RParenLoc);
7147}

7149/// Create a new AsTypeExpr node (bitcast) from the arguments.
7150ExprResult Sema::BuildAsTypeExpr(Expr *E, QualType DestTy,
                               SourceLocation BuiltinLoc,
                               SourceLocation RParenLoc) {
ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType SrcTy = E->getType();
if (!SrcTy->isDependentType() &&
    Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy))
  return ExprError(
      Diag(BuiltinLoc, diag::err_invalid_astype_of_different_size)
      << DestTy << SrcTy << E->getSourceRange());
return new (Context) AsTypeExpr(E, DestTy, VK, OK, BuiltinLoc, RParenLoc);
7162}

7164/// ActOnConvertVectorExpr - create a new convert-vector expression from the
7165/// provided arguments.
7166///
7167/// __builtin_convertvector( value, dst type )
7168///
7169ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
                                      SourceLocation BuiltinLoc,
                                      SourceLocation RParenLoc) {
TypeSourceInfo *TInfo;
GetTypeFromParser(ParsedDestTy, &TInfo);
return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
7175}

7177/// BuildResolvedCallExpr - Build a call to a resolved expression,
7178/// i.e. an expression not of \p OverloadTy.  The expression should
7179/// unary-convert to an expression of function-pointer or
7180/// block-pointer type.
7181///
7182/// \param NDecl the declaration being called, if available
7183ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
                                     SourceLocation LParenLoc,
                                     ArrayRef<Expr *> Args,
                                     SourceLocation RParenLoc, Expr *Config,
                                     bool IsExecConfig, ADLCallKind UsesADL) {
FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0);

// Functions with 'interrupt' attribute cannot be called directly.
if (FDecl && FDecl->hasAttr<AnyX86InterruptAttr>()) {
  Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);
  return ExprError();
}

// Interrupt handlers don't save off the VFP regs automatically on ARM,
// so there's some risk when calling out to non-interrupt handler functions
// that the callee might not preserve them. This is easy to diagnose here,
// but can be very challenging to debug.
// Likewise, X86 interrupt handlers may only call routines with attribute
// no_caller_saved_registers since there is no efficient way to
// save and restore the non-GPR state.
if (auto *Caller = getCurFunctionDecl()) {
  if (Caller->hasAttr<ARMInterruptAttr>()) {
    bool VFP = Context.getTargetInfo().hasFeature("vfp");
    if (VFP && (!FDecl || !FDecl->hasAttr<ARMInterruptAttr>())) {
      Diag(Fn->getExprLoc(), diag::warn_arm_interrupt_calling_convention);
      if (FDecl)
        Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl;
    }
  }
  if (Caller->hasAttr<AnyX86InterruptAttr>() &&
      ((!FDecl || !FDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>()))) {
    Diag(Fn->getExprLoc(), diag::warn_anyx86_interrupt_regsave);
    if (FDecl)
      Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl;
  }
}

// Promote the function operand.
// We special-case function promotion here because we only allow promoting
// builtin functions to function pointers in the callee of a call.
ExprResult Result;
QualType ResultTy;
if (BuiltinID &&
    Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
  // Extract the return type from the (builtin) function pointer type.
  // FIXME Several builtins still have setType in
  // Sema::CheckBuiltinFunctionCall. One should review their definitions in
  // Builtins.def to ensure they are correct before removing setType calls.
  QualType FnPtrTy = Context.getPointerType(FDecl->getType());
  Result = ImpCastExprToType(Fn, FnPtrTy, CK_BuiltinFnToFnPtr).get();
  ResultTy = FDecl->getCallResultType();
} else {
  Result = CallExprUnaryConversions(Fn);
  ResultTy = Context.BoolTy;
}
if (Result.isInvalid())
  return ExprError();
Fn = Result.get();

// Check for a valid function type, but only if it is not a builtin which
// requires custom type checking. These will be handled by
// CheckBuiltinFunctionCall below just after creation of the call expression.
const FunctionType *FuncT = nullptr;
if (!BuiltinID || !Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) {
retry:
  if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) {
    // C99 6.5.2.2p1 - "The expression that denotes the called function shall
    // have type pointer to function".
    FuncT = PT->getPointeeType()->getAs<FunctionType>();
    if (!FuncT)
      return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
                       << Fn->getType() << Fn->getSourceRange());
  } else if (const BlockPointerType *BPT =
                 Fn->getType()->getAs<BlockPointerType>()) {
    FuncT = BPT->getPointeeType()->castAs<FunctionType>();
  } else {
    // Handle calls to expressions of unknown-any type.
    if (Fn->getType() == Context.UnknownAnyTy) {
      ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn);
      if (rewrite.isInvalid())
        return ExprError();
      Fn = rewrite.get();
      goto retry;
    }

    return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
                     << Fn->getType() << Fn->getSourceRange());
  }
}

// Get the number of parameters in the function prototype, if any.
// We will allocate space for max(Args.size(), NumParams) arguments
// in the call expression.
const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
unsigned NumParams = Proto ? Proto->getNumParams() : 0;

CallExpr *TheCall;
if (Config) {
  assert(UsesADL == ADLCallKind::NotADL &&(static_cast <bool> (UsesADL == ADLCallKind::NotADL &&
 "CUDAKernelCallExpr should not use ADL") ? void (0) : __assert_fail
 ("UsesADL == ADLCallKind::NotADL && \"CUDAKernelCallExpr should not use ADL\""
, "clang/lib/Sema/SemaExpr.cpp", 7283, __extension__ __PRETTY_FUNCTION__
))
         "CUDAKernelCallExpr should not use ADL")(static_cast <bool> (UsesADL == ADLCallKind::NotADL &&
 "CUDAKernelCallExpr should not use ADL") ? void (0) : __assert_fail
 ("UsesADL == ADLCallKind::NotADL && \"CUDAKernelCallExpr should not use ADL\""
, "clang/lib/Sema/SemaExpr.cpp", 7283, __extension__ __PRETTY_FUNCTION__
));
  TheCall = CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config),
                                       Args, ResultTy, VK_PRValue, RParenLoc,
                                       CurFPFeatureOverrides(), NumParams);
} else {
  TheCall =
      CallExpr::Create(Context, Fn, Args, ResultTy, VK_PRValue, RParenLoc,
                       CurFPFeatureOverrides(), NumParams, UsesADL);
}

if (!Context.isDependenceAllowed()) {
  // Forget about the nulled arguments since typo correction
  // do not handle them well.
  TheCall->shrinkNumArgs(Args.size());
  // C cannot always handle TypoExpr nodes in builtin calls and direct
  // function calls as their argument checking don't necessarily handle
  // dependent types properly, so make sure any TypoExprs have been
  // dealt with.
  ExprResult Result = CorrectDelayedTyposInExpr(TheCall);
  if (!Result.isUsable()) return ExprError();
  CallExpr *TheOldCall = TheCall;
  TheCall = dyn_cast<CallExpr>(Result.get());
  bool CorrectedTypos = TheCall != TheOldCall;
  if (!TheCall) return Result;
  Args = llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs());

  // A new call expression node was created if some typos were corrected.
  // However it may not have been constructed with enough storage. In this
  // case, rebuild the node with enough storage. The waste of space is
  // immaterial since this only happens when some typos were corrected.
  if (CorrectedTypos && Args.size() < NumParams) {
    if (Config)
      TheCall = CUDAKernelCallExpr::Create(
          Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_PRValue,
          RParenLoc, CurFPFeatureOverrides(), NumParams);
    else
      TheCall =
          CallExpr::Create(Context, Fn, Args, ResultTy, VK_PRValue, RParenLoc,
                           CurFPFeatureOverrides(), NumParams, UsesADL);
  }
  // We can now handle the nulled arguments for the default arguments.
  TheCall->setNumArgsUnsafe(std::max<unsigned>(Args.size(), NumParams));
}

// Bail out early if calling a builtin with custom type checking.
if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID))
  return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);

if (getLangOpts().CUDA) {
  if (Config) {
    // CUDA: Kernel calls must be to global functions
    if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>())
      return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function)
          << FDecl << Fn->getSourceRange());

    // CUDA: Kernel function must have 'void' return type
    if (!FuncT->getReturnType()->isVoidType() &&
        !FuncT->getReturnType()->getAs<AutoType>() &&
        !FuncT->getReturnType()->isInstantiationDependentType())
      return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return)
          << Fn->getType() << Fn->getSourceRange());
  } else {
    // CUDA: Calls to global functions must be configured
    if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())
      return ExprError(Diag(LParenLoc, diag::err_global_call_not_config)
          << FDecl << Fn->getSourceRange());
  }
}

// Check for a valid return type
if (CheckCallReturnType(FuncT->getReturnType(), Fn->getBeginLoc(), TheCall,
                        FDecl))
  return ExprError();

// We know the result type of the call, set it.
TheCall->setType(FuncT->getCallResultType(Context));
TheCall->setValueKind(Expr::getValueKindForType(FuncT->getReturnType()));

if (Proto) {
  if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc,
                              IsExecConfig))
    return ExprError();
} else {
  assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!")(static_cast <bool> (isa<FunctionNoProtoType>(FuncT
) && "Unknown FunctionType!") ? void (0) : __assert_fail
 ("isa<FunctionNoProtoType>(FuncT) && \"Unknown FunctionType!\""
, "clang/lib/Sema/SemaExpr.cpp", 7366, __extension__ __PRETTY_FUNCTION__
));

  if (FDecl) {
    // Check if we have too few/too many template arguments, based
    // on our knowledge of the function definition.
    const FunctionDecl *Def = nullptr;
    if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
      Proto = Def->getType()->getAs<FunctionProtoType>();
     if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
        Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
        << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
    }

    // If the function we're calling isn't a function prototype, but we have
    // a function prototype from a prior declaratiom, use that prototype.
    if (!FDecl->hasPrototype())
      Proto = FDecl->getType()->getAs<FunctionProtoType>();
  }

  // If we still haven't found a prototype to use but there are arguments to
  // the call, diagnose this as calling a function without a prototype.
  // However, if we found a function declaration, check to see if
  // -Wdeprecated-non-prototype was disabled where the function was declared.
  // If so, we will silence the diagnostic here on the assumption that this
  // interface is intentional and the user knows what they're doing. We will
  // also silence the diagnostic if there is a function declaration but it
  // was implicitly defined (the user already gets diagnostics about the
  // creation of the implicit function declaration, so the additional warning
  // is not helpful).
  if (!Proto && !Args.empty() &&
      (!FDecl || (!FDecl->isImplicit() &&
                  !Diags.isIgnored(diag::warn_strict_uses_without_prototype,
                                   FDecl->getLocation()))))
    Diag(LParenLoc, diag::warn_strict_uses_without_prototype)
        << (FDecl != nullptr) << FDecl;

  // Promote the arguments (C99 6.5.2.2p6).
  for (unsigned i = 0, e = Args.size(); i != e; i++) {
    Expr *Arg = Args[i];

    if (Proto && i < Proto->getNumParams()) {
      InitializedEntity Entity = InitializedEntity::InitializeParameter(
          Context, Proto->getParamType(i), Proto->isParamConsumed(i));
      ExprResult ArgE =
          PerformCopyInitialization(Entity, SourceLocation(), Arg);
      if (ArgE.isInvalid())
        return true;

      Arg = ArgE.getAs<Expr>();

    } else {
      ExprResult ArgE = DefaultArgumentPromotion(Arg);

      if (ArgE.isInvalid())
        return true;

      Arg = ArgE.getAs<Expr>();
    }

    if (RequireCompleteType(Arg->getBeginLoc(), Arg->getType(),
                            diag::err_call_incomplete_argument, Arg))
      return ExprError();

    TheCall->setArg(i, Arg);
  }
  TheCall->computeDependence();
}

if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
  if (!Method->isStatic())
    return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
      << Fn->getSourceRange());

// Check for sentinels
if (NDecl)
  DiagnoseSentinelCalls(NDecl, LParenLoc, Args);

// Warn for unions passing across security boundary (CMSE).
if (FuncT != nullptr && FuncT->getCmseNSCallAttr()) {
  for (unsigned i = 0, e = Args.size(); i != e; i++) {
    if (const auto *RT =
            dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {
      if (RT->getDecl()->isOrContainsUnion())
        Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union)
            << 0 << i;
    }
  }
}

// Do special checking on direct calls to functions.
if (FDecl) {
  if (CheckFunctionCall(FDecl, TheCall, Proto))
    return ExprError();

  checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);

  if (BuiltinID)
    return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
} else if (NDecl) {
  if (CheckPointerCall(NDecl, TheCall, Proto))
    return ExprError();
} else {
  if (CheckOtherCall(TheCall, Proto))
    return ExprError();
}

return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FDecl);
7473}

7475ExprResult
7476Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
                         SourceLocation RParenLoc, Expr *InitExpr) {
assert(Ty && "ActOnCompoundLiteral(): missing type")(static_cast <bool> (Ty && "ActOnCompoundLiteral(): missing type"
) ? void (0) : __assert_fail ("Ty && \"ActOnCompoundLiteral(): missing type\""
, "clang/lib/Sema/SemaExpr.cpp", 7478, __extension__ __PRETTY_FUNCTION__
));
assert(InitExpr && "ActOnCompoundLiteral(): missing expression")(static_cast <bool> (InitExpr && "ActOnCompoundLiteral(): missing expression"
) ? void (0) : __assert_fail ("InitExpr && \"ActOnCompoundLiteral(): missing expression\""
, "clang/lib/Sema/SemaExpr.cpp", 7479, __extension__ __PRETTY_FUNCTION__
));

TypeSourceInfo *TInfo;
QualType literalType = GetTypeFromParser(Ty, &TInfo);
if (!TInfo)
  TInfo = Context.getTrivialTypeSourceInfo(literalType);

return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
7487}

7489ExprResult
7490Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
                             SourceLocation RParenLoc, Expr *LiteralExpr) {
QualType literalType = TInfo->getType();

if (literalType->isArrayType()) {
  if (RequireCompleteSizedType(
          LParenLoc, Context.getBaseElementType(literalType),
          diag::err_array_incomplete_or_sizeless_type,
          SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
    return ExprError();
  if (literalType->isVariableArrayType()) {
    // C2x 6.7.9p4: An entity of variable length array type shall not be
    // initialized except by an empty initializer.
    //
    // The C extension warnings are issued from ParseBraceInitializer() and
    // do not need to be issued here. However, we continue to issue an error
    // in the case there are initializers or we are compiling C++. We allow
    // use of VLAs in C++, but it's not clear we want to allow {} to zero
    // init a VLA in C++ in all cases (such as with non-trivial constructors).
    // FIXME: should we allow this construct in C++ when it makes sense to do
    // so?
    std::optional<unsigned> NumInits;
    if (const auto *ILE = dyn_cast<InitListExpr>(LiteralExpr))
      NumInits = ILE->getNumInits();
    if ((LangOpts.CPlusPlus || NumInits.value_or(0)) &&
        !tryToFixVariablyModifiedVarType(TInfo, literalType, LParenLoc,
                                         diag::err_variable_object_no_init))
      return ExprError();
  }
} else if (!literalType->isDependentType() &&
           RequireCompleteType(LParenLoc, literalType,
             diag::err_typecheck_decl_incomplete_type,
             SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
  return ExprError();

InitializedEntity Entity
  = InitializedEntity::InitializeCompoundLiteralInit(TInfo);
InitializationKind Kind
  = InitializationKind::CreateCStyleCast(LParenLoc,
                                         SourceRange(LParenLoc, RParenLoc),
                                         /*InitList=*/true);
InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
                                    &literalType);
if (Result.isInvalid())
  return ExprError();
LiteralExpr = Result.get();

bool isFileScope = !CurContext->isFunctionOrMethod();

// In C, compound literals are l-values for some reason.
// For GCC compatibility, in C++, file-scope array compound literals with
// constant initializers are also l-values, and compound literals are
// otherwise prvalues.
//
// (GCC also treats C++ list-initialized file-scope array prvalues with
// constant initializers as l-values, but that's non-conforming, so we don't
// follow it there.)
//
// FIXME: It would be better to handle the lvalue cases as materializing and
// lifetime-extending a temporary object, but our materialized temporaries
// representation only supports lifetime extension from a variable, not "out
// of thin air".
// FIXME: For C++, we might want to instead lifetime-extend only if a pointer
// is bound to the result of applying array-to-pointer decay to the compound
// literal.
// FIXME: GCC supports compound literals of reference type, which should
// obviously have a value kind derived from the kind of reference involved.
ExprValueKind VK =
    (getLangOpts().CPlusPlus && !(isFileScope && literalType->isArrayType()))
        ? VK_PRValue
        : VK_LValue;

if (isFileScope)
  if (auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
    for (unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
      Expr *Init = ILE->getInit(i);
      ILE->setInit(i, ConstantExpr::Create(Context, Init));
    }

auto *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
                                            VK, LiteralExpr, isFileScope);
if (isFileScope) {
  if (!LiteralExpr->isTypeDependent() &&
      !LiteralExpr->isValueDependent() &&
      !literalType->isDependentType()) // C99 6.5.2.5p3
    if (CheckForConstantInitializer(LiteralExpr, literalType))
      return ExprError();
} else if (literalType.getAddressSpace() != LangAS::opencl_private &&
           literalType.getAddressSpace() != LangAS::Default) {
  // Embedded-C extensions to C99 6.5.2.5:
  //   "If the compound literal occurs inside the body of a function, the
  //   type name shall not be qualified by an address-space qualifier."
  Diag(LParenLoc, diag::err_compound_literal_with_address_space)
    << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
  return ExprError();
}

if (!isFileScope && !getLangOpts().CPlusPlus) {
  // Compound literals that have automatic storage duration are destroyed at
  // the end of the scope in C; in C++, they're just temporaries.

  // Emit diagnostics if it is or contains a C union type that is non-trivial
  // to destruct.
  if (E->getType().hasNonTrivialToPrimitiveDestructCUnion())
    checkNonTrivialCUnion(E->getType(), E->getExprLoc(),
                          NTCUC_CompoundLiteral, NTCUK_Destruct);

  // Diagnose jumps that enter or exit the lifetime of the compound literal.
  if (literalType.isDestructedType()) {
    Cleanup.setExprNeedsCleanups(true);
    ExprCleanupObjects.push_back(E);
    getCurFunction()->setHasBranchProtectedScope();
  }
}

if (E->getType().hasNonTrivialToPrimitiveDefaultInitializeCUnion() ||
    E->getType().hasNonTrivialToPrimitiveCopyCUnion())
  checkNonTrivialCUnionInInitializer(E->getInitializer(),
                                     E->getInitializer()->getExprLoc());

return MaybeBindToTemporary(E);
7612}

7614ExprResult
7615Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
                  SourceLocation RBraceLoc) {
// Only produce each kind of designated initialization diagnostic once.
SourceLocation FirstDesignator;
bool DiagnosedArrayDesignator = false;
bool DiagnosedNestedDesignator = false;
bool DiagnosedMixedDesignator = false;

// Check that any designated initializers are syntactically valid in the
// current language mode.
for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
  if (auto *DIE = dyn_cast<DesignatedInitExpr>(InitArgList[I])) {
    if (FirstDesignator.isInvalid())
      FirstDesignator = DIE->getBeginLoc();

    if (!getLangOpts().CPlusPlus)
      break;

    if (!DiagnosedNestedDesignator && DIE->size() > 1) {
      DiagnosedNestedDesignator = true;
      Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
        << DIE->getDesignatorsSourceRange();
    }

    for (auto &Desig : DIE->designators()) {
      if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
        DiagnosedArrayDesignator = true;
        Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
          << Desig.getSourceRange();
      }
    }

    if (!DiagnosedMixedDesignator &&
        !isa<DesignatedInitExpr>(InitArgList[0])) {
      DiagnosedMixedDesignator = true;
      Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
        << DIE->getSourceRange();
      Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
        << InitArgList[0]->getSourceRange();
    }
  } else if (getLangOpts().CPlusPlus && !DiagnosedMixedDesignator &&
             isa<DesignatedInitExpr>(InitArgList[0])) {
    DiagnosedMixedDesignator = true;
    auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
    Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
      << DIE->getSourceRange();
    Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
      << InitArgList[I]->getSourceRange();
  }
}

if (FirstDesignator.isValid()) {
  // Only diagnose designated initiaization as a C++20 extension if we didn't
  // already diagnose use of (non-C++20) C99 designator syntax.
  if (getLangOpts().CPlusPlus && !DiagnosedArrayDesignator &&
      !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
    Diag(FirstDesignator, getLangOpts().CPlusPlus20
                              ? diag::warn_cxx17_compat_designated_init
                              : diag::ext_cxx_designated_init);
  } else if (!getLangOpts().CPlusPlus && !getLangOpts().C99) {
    Diag(FirstDesignator, diag::ext_designated_init);
  }
}

return BuildInitList(LBraceLoc, InitArgList, RBraceLoc);
7680}

7682ExprResult
7683Sema::BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
                  SourceLocation RBraceLoc) {
// Semantic analysis for initializers is done by ActOnDeclarator() and
// CheckInitializer() - it requires knowledge of the object being initialized.

// Immediately handle non-overload placeholders.  Overloads can be
// resolved contextually, but everything else here can't.
for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
  if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
    ExprResult result = CheckPlaceholderExpr(InitArgList[I]);

    // Ignore failures; dropping the entire initializer list because
    // of one failure would be terrible for indexing/etc.
    if (result.isInvalid()) continue;

    InitArgList[I] = result.get();
  }
}

InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
                                             RBraceLoc);
E->setType(Context.VoidTy); // FIXME: just a place holder for now.
return E;
7706}

7708/// Do an explicit extend of the given block pointer if we're in ARC.
7709void Sema::maybeExtendBlockObject(ExprResult &E) {
assert(E.get()->getType()->isBlockPointerType())(static_cast <bool> (E.get()->getType()->isBlockPointerType
()) ? void (0) : __assert_fail ("E.get()->getType()->isBlockPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 7710, __extension__ __PRETTY_FUNCTION__
));
assert(E.get()->isPRValue())(static_cast <bool> (E.get()->isPRValue()) ? void (0
) : __assert_fail ("E.get()->isPRValue()", "clang/lib/Sema/SemaExpr.cpp"
, 7711, __extension__ __PRETTY_FUNCTION__));

// Only do this in an r-value context.
if (!getLangOpts().ObjCAutoRefCount) return;

E = ImplicitCastExpr::Create(
    Context, E.get()->getType(), CK_ARCExtendBlockObject, E.get(),
    /*base path*/ nullptr, VK_PRValue, FPOptionsOverride());
Cleanup.setExprNeedsCleanups(true);
7720}

7722/// Prepare a conversion of the given expression to an ObjC object
7723/// pointer type.
7724CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) {
QualType type = E.get()->getType();
if (type->isObjCObjectPointerType()) {
  return CK_BitCast;
} else if (type->isBlockPointerType()) {
  maybeExtendBlockObject(E);
  return CK_BlockPointerToObjCPointerCast;
} else {
  assert(type->isPointerType())(static_cast <bool> (type->isPointerType()) ? void (
0) : __assert_fail ("type->isPointerType()", "clang/lib/Sema/SemaExpr.cpp"
, 7732, __extension__ __PRETTY_FUNCTION__));
  return CK_CPointerToObjCPointerCast;
}
7735}

7737/// Prepares for a scalar cast, performing all the necessary stages
7738/// except the final cast and returning the kind required.
7739CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {
// Both Src and Dest are scalar types, i.e. arithmetic or pointer.
// Also, callers should have filtered out the invalid cases with
// pointers.  Everything else should be possible.

QualType SrcTy = Src.get()->getType();
if (Context.hasSameUnqualifiedType(SrcTy, DestTy))
  return CK_NoOp;

switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) {
case Type::STK_MemberPointer:
  llvm_unreachable("member pointer type in C")::llvm::llvm_unreachable_internal("member pointer type in C",
 "clang/lib/Sema/SemaExpr.cpp", 7750);

case Type::STK_CPointer:
case Type::STK_BlockPointer:
case Type::STK_ObjCObjectPointer:
  switch (DestTy->getScalarTypeKind()) {
  case Type::STK_CPointer: {
    LangAS SrcAS = SrcTy->getPointeeType().getAddressSpace();
    LangAS DestAS = DestTy->getPointeeType().getAddressSpace();
    if (SrcAS != DestAS)
      return CK_AddressSpaceConversion;
    if (Context.hasCvrSimilarType(SrcTy, DestTy))
      return CK_NoOp;
    return CK_BitCast;
  }
  case Type::STK_BlockPointer:
    return (SrcKind == Type::STK_BlockPointer
              ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
  case Type::STK_ObjCObjectPointer:
    if (SrcKind == Type::STK_ObjCObjectPointer)
      return CK_BitCast;
    if (SrcKind == Type::STK_CPointer)
      return CK_CPointerToObjCPointerCast;
    maybeExtendBlockObject(Src);
    return CK_BlockPointerToObjCPointerCast;
  case Type::STK_Bool:
    return CK_PointerToBoolean;
  case Type::STK_Integral:
    return CK_PointerToIntegral;
  case Type::STK_Floating:
  case Type::STK_FloatingComplex:
  case Type::STK_IntegralComplex:
  case Type::STK_MemberPointer:
  case Type::STK_FixedPoint:
    llvm_unreachable("illegal cast from pointer")::llvm::llvm_unreachable_internal("illegal cast from pointer"
, "clang/lib/Sema/SemaExpr.cpp", 7784);
  }
  llvm_unreachable("Should have returned before this")::llvm::llvm_unreachable_internal("Should have returned before this"
, "clang/lib/Sema/SemaExpr.cpp", 7786);

case Type::STK_FixedPoint:
  switch (DestTy->getScalarTypeKind()) {
  case Type::STK_FixedPoint:
    return CK_FixedPointCast;
  case Type::STK_Bool:
    return CK_FixedPointToBoolean;
  case Type::STK_Integral:
    return CK_FixedPointToIntegral;
  case Type::STK_Floating:
    return CK_FixedPointToFloating;
  case Type::STK_IntegralComplex:
  case Type::STK_FloatingComplex:
    Diag(Src.get()->getExprLoc(),
         diag::err_unimplemented_conversion_with_fixed_point_type)
        << DestTy;
    return CK_IntegralCast;
  case Type::STK_CPointer:
  case Type::STK_ObjCObjectPointer:
  case Type::STK_BlockPointer:
  case Type::STK_MemberPointer:
    llvm_unreachable("illegal cast to pointer type")::llvm::llvm_unreachable_internal("illegal cast to pointer type"
, "clang/lib/Sema/SemaExpr.cpp", 7808);
  }
  llvm_unreachable("Should have returned before this")::llvm::llvm_unreachable_internal("Should have returned before this"
, "clang/lib/Sema/SemaExpr.cpp", 7810);

case Type::STK_Bool: // casting from bool is like casting from an integer
case Type::STK_Integral:
  switch (DestTy->getScalarTypeKind()) {
  case Type::STK_CPointer:
  case Type::STK_ObjCObjectPointer:
  case Type::STK_BlockPointer:
    if (Src.get()->isNullPointerConstant(Context,
                                         Expr::NPC_ValueDependentIsNull))
      return CK_NullToPointer;
    return CK_IntegralToPointer;
  case Type::STK_Bool:
    return CK_IntegralToBoolean;
  case Type::STK_Integral:
    return CK_IntegralCast;
  case Type::STK_Floating:
    return CK_IntegralToFloating;
  case Type::STK_IntegralComplex:
    Src = ImpCastExprToType(Src.get(),
                    DestTy->castAs<ComplexType>()->getElementType(),
                    CK_IntegralCast);
    return CK_IntegralRealToComplex;
  case Type::STK_FloatingComplex:
    Src = ImpCastExprToType(Src.get(),
                    DestTy->castAs<ComplexType>()->getElementType(),
                    CK_IntegralToFloating);
    return CK_FloatingRealToComplex;
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")::llvm::llvm_unreachable_internal("member pointer type in C",
 "clang/lib/Sema/SemaExpr.cpp", 7839);
  case Type::STK_FixedPoint:
    return CK_IntegralToFixedPoint;
  }
  llvm_unreachable("Should have returned before this")::llvm::llvm_unreachable_internal("Should have returned before this"
, "clang/lib/Sema/SemaExpr.cpp", 7843);

case Type::STK_Floating:
  switch (DestTy->getScalarTypeKind()) {
  case Type::STK_Floating:
    return CK_FloatingCast;
  case Type::STK_Bool:
    return CK_FloatingToBoolean;
  case Type::STK_Integral:
    return CK_FloatingToIntegral;
  case Type::STK_FloatingComplex:
    Src = ImpCastExprToType(Src.get(),
                            DestTy->castAs<ComplexType>()->getElementType(),
                            CK_FloatingCast);
    return CK_FloatingRealToComplex;
  case Type::STK_IntegralComplex:
    Src = ImpCastExprToType(Src.get(),
                            DestTy->castAs<ComplexType>()->getElementType(),
                            CK_FloatingToIntegral);
    return CK_IntegralRealToComplex;
  case Type::STK_CPointer:
  case Type::STK_ObjCObjectPointer:
  case Type::STK_BlockPointer:
    llvm_unreachable("valid float->pointer cast?")::llvm::llvm_unreachable_internal("valid float->pointer cast?"
, "clang/lib/Sema/SemaExpr.cpp", 7866);
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")::llvm::llvm_unreachable_internal("member pointer type in C",
 "clang/lib/Sema/SemaExpr.cpp", 7868);
  case Type::STK_FixedPoint:
    return CK_FloatingToFixedPoint;
  }
  llvm_unreachable("Should have returned before this")::llvm::llvm_unreachable_internal("Should have returned before this"
, "clang/lib/Sema/SemaExpr.cpp", 7872);

case Type::STK_FloatingComplex:
  switch (DestTy->getScalarTypeKind()) {
  case Type::STK_FloatingComplex:
    return CK_FloatingComplexCast;
  case Type::STK_IntegralComplex:
    return CK_FloatingComplexToIntegralComplex;
  case Type::STK_Floating: {
    QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
    if (Context.hasSameType(ET, DestTy))
      return CK_FloatingComplexToReal;
    Src = ImpCastExprToType(Src.get(), ET, CK_FloatingComplexToReal);
    return CK_FloatingCast;
  }
  case Type::STK_Bool:
    return CK_FloatingComplexToBoolean;
  case Type::STK_Integral:
    Src = ImpCastExprToType(Src.get(),
                            SrcTy->castAs<ComplexType>()->getElementType(),
                            CK_FloatingComplexToReal);
    return CK_FloatingToIntegral;
  case Type::STK_CPointer:
  case Type::STK_ObjCObjectPointer:
  case Type::STK_BlockPointer:
    llvm_unreachable("valid complex float->pointer cast?")::llvm::llvm_unreachable_internal("valid complex float->pointer cast?"
, "clang/lib/Sema/SemaExpr.cpp", 7897);
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")::llvm::llvm_unreachable_internal("member pointer type in C",
 "clang/lib/Sema/SemaExpr.cpp", 7899);
  case Type::STK_FixedPoint:
    Diag(Src.get()->getExprLoc(),
         diag::err_unimplemented_conversion_with_fixed_point_type)
        << SrcTy;
    return CK_IntegralCast;
  }
  llvm_unreachable("Should have returned before this")::llvm::llvm_unreachable_internal("Should have returned before this"
, "clang/lib/Sema/SemaExpr.cpp", 7906);

case Type::STK_IntegralComplex:
  switch (DestTy->getScalarTypeKind()) {
  case Type::STK_FloatingComplex:
    return CK_IntegralComplexToFloatingComplex;
  case Type::STK_IntegralComplex:
    return CK_IntegralComplexCast;
  case Type::STK_Integral: {
    QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
    if (Context.hasSameType(ET, DestTy))
      return CK_IntegralComplexToReal;
    Src = ImpCastExprToType(Src.get(), ET, CK_IntegralComplexToReal);
    return CK_IntegralCast;
  }
  case Type::STK_Bool:
    return CK_IntegralComplexToBoolean;
  case Type::STK_Floating:
    Src = ImpCastExprToType(Src.get(),
                            SrcTy->castAs<ComplexType>()->getElementType(),
                            CK_IntegralComplexToReal);
    return CK_IntegralToFloating;
  case Type::STK_CPointer:
  case Type::STK_ObjCObjectPointer:
  case Type::STK_BlockPointer:
    llvm_unreachable("valid complex int->pointer cast?")::llvm::llvm_unreachable_internal("valid complex int->pointer cast?"
, "clang/lib/Sema/SemaExpr.cpp", 7931);
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")::llvm::llvm_unreachable_internal("member pointer type in C",
 "clang/lib/Sema/SemaExpr.cpp", 7933);
  case Type::STK_FixedPoint:
    Diag(Src.get()->getExprLoc(),
         diag::err_unimplemented_conversion_with_fixed_point_type)
        << SrcTy;
    return CK_IntegralCast;
  }
  llvm_unreachable("Should have returned before this")::llvm::llvm_unreachable_internal("Should have returned before this"
, "clang/lib/Sema/SemaExpr.cpp", 7940);
}

llvm_unreachable("Unhandled scalar cast")::llvm::llvm_unreachable_internal("Unhandled scalar cast", "clang/lib/Sema/SemaExpr.cpp"
, 7943);
7944}

7946static bool breakDownVectorType(QualType type, uint64_t &len,
                              QualType &eltType) {
// Vectors are simple.
if (const VectorType *vecType = type->getAs<VectorType>()) {
  len = vecType->getNumElements();
  eltType = vecType->getElementType();
  assert(eltType->isScalarType())(static_cast <bool> (eltType->isScalarType()) ? void
 (0) : __assert_fail ("eltType->isScalarType()", "clang/lib/Sema/SemaExpr.cpp"
, 7952, __extension__ __PRETTY_FUNCTION__));
  return true;
}

// We allow lax conversion to and from non-vector types, but only if
// they're real types (i.e. non-complex, non-pointer scalar types).
if (!type->isRealType()) return false;

len = 1;
eltType = type;
return true;
7963}

7965/// Are the two types SVE-bitcast-compatible types? I.e. is bitcasting from the
7966/// first SVE type (e.g. an SVE VLAT) to the second type (e.g. an SVE VLST)
7967/// allowed?
7968///
7969/// This will also return false if the two given types do not make sense from
7970/// the perspective of SVE bitcasts.
7971bool Sema::isValidSveBitcast(QualType srcTy, QualType destTy) {
assert(srcTy->isVectorType() || destTy->isVectorType())(static_cast <bool> (srcTy->isVectorType() || destTy
->isVectorType()) ? void (0) : __assert_fail ("srcTy->isVectorType() || destTy->isVectorType()"
, "clang/lib/Sema/SemaExpr.cpp", 7972, __extension__ __PRETTY_FUNCTION__
));

auto ValidScalableConversion = [](QualType FirstType, QualType SecondType) {
  if (!FirstType->isSVESizelessBuiltinType())
    return false;

  const auto *VecTy = SecondType->getAs<VectorType>();
  return VecTy &&
         VecTy->getVectorKind() == VectorType::SveFixedLengthDataVector;
};

return ValidScalableConversion(srcTy, destTy) ||
       ValidScalableConversion(destTy, srcTy);
7985}

7987/// Are the two types RVV-bitcast-compatible types? I.e. is bitcasting from the
7988/// first RVV type (e.g. an RVV scalable type) to the second type (e.g. an RVV
7989/// VLS type) allowed?
7990///
7991/// This will also return false if the two given types do not make sense from
7992/// the perspective of RVV bitcasts.
7993bool Sema::isValidRVVBitcast(QualType srcTy, QualType destTy) {
assert(srcTy->isVectorType() || destTy->isVectorType())(static_cast <bool> (srcTy->isVectorType() || destTy
->isVectorType()) ? void (0) : __assert_fail ("srcTy->isVectorType() || destTy->isVectorType()"
, "clang/lib/Sema/SemaExpr.cpp", 7994, __extension__ __PRETTY_FUNCTION__
));

auto ValidScalableConversion = [](QualType FirstType, QualType SecondType) {
  if (!FirstType->isRVVSizelessBuiltinType())
    return false;

  const auto *VecTy = SecondType->getAs<VectorType>();
  return VecTy &&
         VecTy->getVectorKind() == VectorType::RVVFixedLengthDataVector;
};

return ValidScalableConversion(srcTy, destTy) ||
       ValidScalableConversion(destTy, srcTy);
8007}

8009/// Are the two types matrix types and do they have the same dimensions i.e.
8010/// do they have the same number of rows and the same number of columns?
8011bool Sema::areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy) {
if (!destTy->isMatrixType() || !srcTy->isMatrixType())
  return false;

const ConstantMatrixType *matSrcType = srcTy->getAs<ConstantMatrixType>();
const ConstantMatrixType *matDestType = destTy->getAs<ConstantMatrixType>();

return matSrcType->getNumRows() == matDestType->getNumRows() &&
       matSrcType->getNumColumns() == matDestType->getNumColumns();
8020}

8022bool Sema::areVectorTypesSameSize(QualType SrcTy, QualType DestTy) {
assert(DestTy->isVectorType() || SrcTy->isVectorType())(static_cast <bool> (DestTy->isVectorType() || SrcTy
->isVectorType()) ? void (0) : __assert_fail ("DestTy->isVectorType() || SrcTy->isVectorType()"
, "clang/lib/Sema/SemaExpr.cpp", 8023, __extension__ __PRETTY_FUNCTION__
));

uint64_t SrcLen, DestLen;
QualType SrcEltTy, DestEltTy;
if (!breakDownVectorType(SrcTy, SrcLen, SrcEltTy))
  return false;
if (!breakDownVectorType(DestTy, DestLen, DestEltTy))
  return false;

// ASTContext::getTypeSize will return the size rounded up to a
// power of 2, so instead of using that, we need to use the raw
// element size multiplied by the element count.
uint64_t SrcEltSize = Context.getTypeSize(SrcEltTy);
uint64_t DestEltSize = Context.getTypeSize(DestEltTy);

return (SrcLen * SrcEltSize == DestLen * DestEltSize);
8039}

8041// This returns true if at least one of the types is an altivec vector.
8042bool Sema::anyAltivecTypes(QualType SrcTy, QualType DestTy) {
assert((DestTy->isVectorType() || SrcTy->isVectorType()) &&(static_cast <bool> ((DestTy->isVectorType() || SrcTy
->isVectorType()) && "expected at least one type to be a vector here"
) ? void (0) : __assert_fail ("(DestTy->isVectorType() || SrcTy->isVectorType()) && \"expected at least one type to be a vector here\""
, "clang/lib/Sema/SemaExpr.cpp", 8044, __extension__ __PRETTY_FUNCTION__
))
       "expected at least one type to be a vector here")(static_cast <bool> ((DestTy->isVectorType() || SrcTy
->isVectorType()) && "expected at least one type to be a vector here"
) ? void (0) : __assert_fail ("(DestTy->isVectorType() || SrcTy->isVectorType()) && \"expected at least one type to be a vector here\""
, "clang/lib/Sema/SemaExpr.cpp", 8044, __extension__ __PRETTY_FUNCTION__
));

bool IsSrcTyAltivec =
    SrcTy->isVectorType() && ((SrcTy->castAs<VectorType>()->getVectorKind() ==
                               VectorType::AltiVecVector) ||
                              (SrcTy->castAs<VectorType>()->getVectorKind() ==
                               VectorType::AltiVecBool) ||
                              (SrcTy->castAs<VectorType>()->getVectorKind() ==
                               VectorType::AltiVecPixel));

bool IsDestTyAltivec = DestTy->isVectorType() &&
                       ((DestTy->castAs<VectorType>()->getVectorKind() ==
                         VectorType::AltiVecVector) ||
                        (DestTy->castAs<VectorType>()->getVectorKind() ==
                         VectorType::AltiVecBool) ||
                        (DestTy->castAs<VectorType>()->getVectorKind() ==
                         VectorType::AltiVecPixel));

return (IsSrcTyAltivec || IsDestTyAltivec);
8063}

8065/// Are the two types lax-compatible vector types?  That is, given
8066/// that one of them is a vector, do they have equal storage sizes,
8067/// where the storage size is the number of elements times the element
8068/// size?
8069///
8070/// This will also return false if either of the types is neither a
8071/// vector nor a real type.
8072bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
assert(destTy->isVectorType() || srcTy->isVectorType())(static_cast <bool> (destTy->isVectorType() || srcTy
->isVectorType()) ? void (0) : __assert_fail ("destTy->isVectorType() || srcTy->isVectorType()"
, "clang/lib/Sema/SemaExpr.cpp", 8073, __extension__ __PRETTY_FUNCTION__
));

// Disallow lax conversions between scalars and ExtVectors (these
// conversions are allowed for other vector types because common headers
// depend on them).  Most scalar OP ExtVector cases are handled by the
// splat path anyway, which does what we want (convert, not bitcast).
// What this rules out for ExtVectors is crazy things like char4*float.
if (srcTy->isScalarType() && destTy->isExtVectorType()) return false;
if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;

return areVectorTypesSameSize(srcTy, destTy);
8084}

8086/// Is this a legal conversion between two types, one of which is
8087/// known to be a vector type?
8088bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) {
assert(destTy->isVectorType() || srcTy->isVectorType())(static_cast <bool> (destTy->isVectorType() || srcTy
->isVectorType()) ? void (0) : __assert_fail ("destTy->isVectorType() || srcTy->isVectorType()"
, "clang/lib/Sema/SemaExpr.cpp", 8089, __extension__ __PRETTY_FUNCTION__
));

switch (Context.getLangOpts().getLaxVectorConversions()) {
case LangOptions::LaxVectorConversionKind::None:
  return false;

case LangOptions::LaxVectorConversionKind::Integer:
  if (!srcTy->isIntegralOrEnumerationType()) {
    auto *Vec = srcTy->getAs<VectorType>();
    if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
      return false;
  }
  if (!destTy->isIntegralOrEnumerationType()) {
    auto *Vec = destTy->getAs<VectorType>();
    if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
      return false;
  }
  // OK, integer (vector) -> integer (vector) bitcast.
  break;

  case LangOptions::LaxVectorConversionKind::All:
  break;
}

return areLaxCompatibleVectorTypes(srcTy, destTy);
8114}

8116bool Sema::CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
                         CastKind &Kind) {
if (SrcTy->isMatrixType() && DestTy->isMatrixType()) {
  if (!areMatrixTypesOfTheSameDimension(SrcTy, DestTy)) {
    return Diag(R.getBegin(), diag::err_invalid_conversion_between_matrixes)
           << DestTy << SrcTy << R;
  }
} else if (SrcTy->isMatrixType()) {
  return Diag(R.getBegin(),
              diag::err_invalid_conversion_between_matrix_and_type)
         << SrcTy << DestTy << R;
} else if (DestTy->isMatrixType()) {
  return Diag(R.getBegin(),
              diag::err_invalid_conversion_between_matrix_and_type)
         << DestTy << SrcTy << R;
}

Kind = CK_MatrixCast;
return false;
8135}

8137bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
                         CastKind &Kind) {
assert(VectorTy->isVectorType() && "Not a vector type!")(static_cast <bool> (VectorTy->isVectorType() &&
 "Not a vector type!") ? void (0) : __assert_fail ("VectorTy->isVectorType() && \"Not a vector type!\""
, "clang/lib/Sema/SemaExpr.cpp", 8139, __extension__ __PRETTY_FUNCTION__
));

if (Ty->isVectorType() || Ty->isIntegralType(Context)) {
  if (!areLaxCompatibleVectorTypes(Ty, VectorTy))
    return Diag(R.getBegin(),
                Ty->isVectorType() ?
                diag::err_invalid_conversion_between_vectors :
                diag::err_invalid_conversion_between_vector_and_integer)
      << VectorTy << Ty << R;
} else
  return Diag(R.getBegin(),
              diag::err_invalid_conversion_between_vector_and_scalar)
    << VectorTy << Ty << R;

Kind = CK_BitCast;
return false;
8155}

8157ExprResult Sema::prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr) {
QualType DestElemTy = VectorTy->castAs<VectorType>()->getElementType();

if (DestElemTy == SplattedExpr->getType())
  return SplattedExpr;

assert(DestElemTy->isFloatingType() ||(static_cast <bool> (DestElemTy->isFloatingType() ||
 DestElemTy->isIntegralOrEnumerationType()) ? void (0) : __assert_fail
 ("DestElemTy->isFloatingType() || DestElemTy->isIntegralOrEnumerationType()"
, "clang/lib/Sema/SemaExpr.cpp", 8164, __extension__ __PRETTY_FUNCTION__
))
       DestElemTy->isIntegralOrEnumerationType())(static_cast <bool> (DestElemTy->isFloatingType() ||
 DestElemTy->isIntegralOrEnumerationType()) ? void (0) : __assert_fail
 ("DestElemTy->isFloatingType() || DestElemTy->isIntegralOrEnumerationType()"
, "clang/lib/Sema/SemaExpr.cpp", 8164, __extension__ __PRETTY_FUNCTION__
));

CastKind CK;
if (VectorTy->isExtVectorType() && SplattedExpr->getType()->isBooleanType()) {
  // OpenCL requires that we convert `true` boolean expressions to -1, but
  // only when splatting vectors.
  if (DestElemTy->isFloatingType()) {
    // To avoid having to have a CK_BooleanToSignedFloating cast kind, we cast
    // in two steps: boolean to signed integral, then to floating.
    ExprResult CastExprRes = ImpCastExprToType(SplattedExpr, Context.IntTy,
                                               CK_BooleanToSignedIntegral);
    SplattedExpr = CastExprRes.get();
    CK = CK_IntegralToFloating;
  } else {
    CK = CK_BooleanToSignedIntegral;
  }
} else {
  ExprResult CastExprRes = SplattedExpr;
  CK = PrepareScalarCast(CastExprRes, DestElemTy);
  if (CastExprRes.isInvalid())
    return ExprError();
  SplattedExpr = CastExprRes.get();
}
return ImpCastExprToType(SplattedExpr, DestElemTy, CK);
8188}

8190ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
                                  Expr *CastExpr, CastKind &Kind) {
assert(DestTy->isExtVectorType() && "Not an extended vector type!")(static_cast <bool> (DestTy->isExtVectorType() &&
 "Not an extended vector type!") ? void (0) : __assert_fail (
"DestTy->isExtVectorType() && \"Not an extended vector type!\""
, "clang/lib/Sema/SemaExpr.cpp", 8192, __extension__ __PRETTY_FUNCTION__
));

QualType SrcTy = CastExpr->getType();

// If SrcTy is a VectorType, the total size must match to explicitly cast to
// an ExtVectorType.
// In OpenCL, casts between vectors of different types are not allowed.
// (See OpenCL 6.2).
if (SrcTy->isVectorType()) {
  if (!areLaxCompatibleVectorTypes(SrcTy, DestTy) ||
      (getLangOpts().OpenCL &&
       !Context.hasSameUnqualifiedType(DestTy, SrcTy))) {
    Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
      << DestTy << SrcTy << R;
    return ExprError();
  }
  Kind = CK_BitCast;
  return CastExpr;
}

// All non-pointer scalars can be cast to ExtVector type.  The appropriate
// conversion will take place first from scalar to elt type, and then
// splat from elt type to vector.
if (SrcTy->isPointerType())
  return Diag(R.getBegin(),
              diag::err_invalid_conversion_between_vector_and_scalar)
    << DestTy << SrcTy << R;

Kind = CK_VectorSplat;
return prepareVectorSplat(DestTy, CastExpr);
8222}

8224ExprResult
8225Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
                  Declarator &D, ParsedType &Ty,
                  SourceLocation RParenLoc, Expr *CastExpr) {
assert(!D.isInvalidType() && (CastExpr != nullptr) &&(static_cast <bool> (!D.isInvalidType() && (CastExpr
 != nullptr) && "ActOnCastExpr(): missing type or expr"
) ? void (0) : __assert_fail ("!D.isInvalidType() && (CastExpr != nullptr) && \"ActOnCastExpr(): missing type or expr\""
, "clang/lib/Sema/SemaExpr.cpp", 8229, __extension__ __PRETTY_FUNCTION__
))
       "ActOnCastExpr(): missing type or expr")(static_cast <bool> (!D.isInvalidType() && (CastExpr
 != nullptr) && "ActOnCastExpr(): missing type or expr"
) ? void (0) : __assert_fail ("!D.isInvalidType() && (CastExpr != nullptr) && \"ActOnCastExpr(): missing type or expr\""
, "clang/lib/Sema/SemaExpr.cpp", 8229, __extension__ __PRETTY_FUNCTION__
));

TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType());
if (D.isInvalidType())
  return ExprError();

if (getLangOpts().CPlusPlus) {
  // Check that there are no default arguments (C++ only).
  CheckExtraCXXDefaultArguments(D);
} else {
  // Make sure any TypoExprs have been dealt with.
  ExprResult Res = CorrectDelayedTyposInExpr(CastExpr);
  if (!Res.isUsable())
    return ExprError();
  CastExpr = Res.get();
}

checkUnusedDeclAttributes(D);

QualType castType = castTInfo->getType();
Ty = CreateParsedType(castType, castTInfo);

bool isVectorLiteral = false;

// Check for an altivec or OpenCL literal,
// i.e. all the elements are integer constants.
ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr);
ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr);
if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL)
     && castType->isVectorType() && (PE || PLE)) {
  if (PLE && PLE->getNumExprs() == 0) {
    Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);
    return ExprError();
  }
  if (PE || PLE->getNumExprs() == 1) {
    Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
    if (!E->isTypeDependent() && !E->getType()->isVectorType())
      isVectorLiteral = true;
  }
  else
    isVectorLiteral = true;
}

// If this is a vector initializer, '(' type ')' '(' init, ..., init ')'
// then handle it as such.
if (isVectorLiteral)
  return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo);

// If the Expr being casted is a ParenListExpr, handle it specially.
// This is not an AltiVec-style cast, so turn the ParenListExpr into a
// sequence of BinOp comma operators.
if (isa<ParenListExpr>(CastExpr)) {
  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
  if (Result.isInvalid()) return ExprError();
  CastExpr = Result.get();
}

if (getLangOpts().CPlusPlus && !castType->isVoidType())
  Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange();

CheckTollFreeBridgeCast(castType, CastExpr);

CheckObjCBridgeRelatedCast(castType, CastExpr);

DiscardMisalignedMemberAddress(castType.getTypePtr(), CastExpr);

return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr);
8296}

8298ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
                                  SourceLocation RParenLoc, Expr *E,
                                  TypeSourceInfo *TInfo) {
assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&(static_cast <bool> ((isa<ParenListExpr>(E) || isa
<ParenExpr>(E)) && "Expected paren or paren list expression"
) ? void (0) : __assert_fail ("(isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && \"Expected paren or paren list expression\""
, "clang/lib/Sema/SemaExpr.cpp", 8302, __extension__ __PRETTY_FUNCTION__
))
       "Expected paren or paren list expression")(static_cast <bool> ((isa<ParenListExpr>(E) || isa
<ParenExpr>(E)) && "Expected paren or paren list expression"
) ? void (0) : __assert_fail ("(isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && \"Expected paren or paren list expression\""
, "clang/lib/Sema/SemaExpr.cpp", 8302, __extension__ __PRETTY_FUNCTION__
));

Expr **exprs;
unsigned numExprs;
Expr *subExpr;
SourceLocation LiteralLParenLoc, LiteralRParenLoc;
if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) {
  LiteralLParenLoc = PE->getLParenLoc();
  LiteralRParenLoc = PE->getRParenLoc();
  exprs = PE->getExprs();
  numExprs = PE->getNumExprs();
} else { // isa<ParenExpr> by assertion at function entrance
  LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
  LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
  subExpr = cast<ParenExpr>(E)->getSubExpr();
  exprs = &subExpr;
  numExprs = 1;
}

QualType Ty = TInfo->getType();
assert(Ty->isVectorType() && "Expected vector type")(static_cast <bool> (Ty->isVectorType() && "Expected vector type"
) ? void (0) : __assert_fail ("Ty->isVectorType() && \"Expected vector type\""
, "clang/lib/Sema/SemaExpr.cpp", 8322, __extension__ __PRETTY_FUNCTION__
));

SmallVector<Expr *, 8> initExprs;
const VectorType *VTy = Ty->castAs<VectorType>();
unsigned numElems = VTy->getNumElements();

// '(...)' form of vector initialization in AltiVec: the number of
// initializers must be one or must match the size of the vector.
// If a single value is specified in the initializer then it will be
// replicated to all the components of the vector
if (CheckAltivecInitFromScalar(E->getSourceRange(), Ty,
                               VTy->getElementType()))
  return ExprError();
if (ShouldSplatAltivecScalarInCast(VTy)) {
  // The number of initializers must be one or must match the size of the
  // vector. If a single value is specified in the initializer then it will
  // be replicated to all the components of the vector
  if (numExprs == 1) {
    QualType ElemTy = VTy->getElementType();
    ExprResult Literal = DefaultLvalueConversion(exprs[0]);
    if (Literal.isInvalid())
      return ExprError();
    Literal = ImpCastExprToType(Literal.get(), ElemTy,
                                PrepareScalarCast(Literal, ElemTy));
    return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
  }
  else if (numExprs < numElems) {
    Diag(E->getExprLoc(),
         diag::err_incorrect_number_of_vector_initializers);
    return ExprError();
  }
  else
    initExprs.append(exprs, exprs + numExprs);
}
else {
  // For OpenCL, when the number of initializers is a single value,
  // it will be replicated to all components of the vector.
  if (getLangOpts().OpenCL &&
      VTy->getVectorKind() == VectorType::GenericVector &&
      numExprs == 1) {
      QualType ElemTy = VTy->getElementType();
      ExprResult Literal = DefaultLvalueConversion(exprs[0]);
      if (Literal.isInvalid())
        return ExprError();
      Literal = ImpCastExprToType(Literal.get(), ElemTy,
                                  PrepareScalarCast(Literal, ElemTy));
      return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
  }

  initExprs.append(exprs, exprs + numExprs);
}
// FIXME: This means that pretty-printing the final AST will produce curly
// braces instead of the original commas.
InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
                                                 initExprs, LiteralRParenLoc);
initE->setType(Ty);
return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE);
8379}

8381/// This is not an AltiVec-style cast or or C++ direct-initialization, so turn
8382/// the ParenListExpr into a sequence of comma binary operators.
8383ExprResult
8384Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) {
ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr);
if (!E)
  return OrigExpr;

ExprResult Result(E->getExpr(0));

for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
  Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
                      E->getExpr(i));

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

return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
8398}

8400ExprResult Sema::ActOnParenListExpr(SourceLocation L,
                                  SourceLocation R,
                                  MultiExprArg Val) {
return ParenListExpr::Create(Context, L, Val, R);
8404}

8406/// Emit a specialized diagnostic when one expression is a null pointer
8407/// constant and the other is not a pointer.  Returns true if a diagnostic is
8408/// emitted.
8409bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
                                    SourceLocation QuestionLoc) {
Expr *NullExpr = LHSExpr;
Expr *NonPointerExpr = RHSExpr;
Expr::NullPointerConstantKind NullKind =
    NullExpr->isNullPointerConstant(Context,
                                    Expr::NPC_ValueDependentIsNotNull);

if (NullKind == Expr::NPCK_NotNull) {
  NullExpr = RHSExpr;
  NonPointerExpr = LHSExpr;
  NullKind =
      NullExpr->isNullPointerConstant(Context,
                                      Expr::NPC_ValueDependentIsNotNull);
}

if (NullKind == Expr::NPCK_NotNull)
  return false;

if (NullKind == Expr::NPCK_ZeroExpression)
  return false;

if (NullKind == Expr::NPCK_ZeroLiteral) {
  // In this case, check to make sure that we got here from a "NULL"
  // string in the source code.
  NullExpr = NullExpr->IgnoreParenImpCasts();
  SourceLocation loc = NullExpr->getExprLoc();
  if (!findMacroSpelling(loc, "NULL"))
    return false;
}

int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr);
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
    << NonPointerExpr->getType() << DiagType
    << NonPointerExpr->getSourceRange();
return true;
8445}

8447/// Return false if the condition expression is valid, true otherwise.
8448static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc) {
QualType CondTy = Cond->getType();

// OpenCL v1.1 s6.3.i says the condition cannot be a floating point type.
if (S.getLangOpts().OpenCL && CondTy->isFloatingType()) {
  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
    << CondTy << Cond->getSourceRange();
  return true;
}

// C99 6.5.15p2
if (CondTy->isScalarType()) return false;

S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
  << CondTy << Cond->getSourceRange();
return true;
8464}

8466/// Return false if the NullExpr can be promoted to PointerTy,
8467/// true otherwise.
8468static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr,
                                      QualType PointerTy) {
if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) ||
    !NullExpr.get()->isNullPointerConstant(S.Context,
                                          Expr::NPC_ValueDependentIsNull))
  return true;

NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer);
return false;
8477}

8479/// Checks compatibility between two pointers and return the resulting
8480/// type.
8481static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS,
                                                   ExprResult &RHS,
                                                   SourceLocation Loc) {
QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();

if (S.Context.hasSameType(LHSTy, RHSTy)) {
  // Two identical pointers types are always compatible.
  return S.Context.getCommonSugaredType(LHSTy, RHSTy);
}

QualType lhptee, rhptee;

// Get the pointee types.
bool IsBlockPointer = false;
if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) {
  lhptee = LHSBTy->getPointeeType();
  rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType();
  IsBlockPointer = true;
} else {
  lhptee = LHSTy->castAs<PointerType>()->getPointeeType();
  rhptee = RHSTy->castAs<PointerType>()->getPointeeType();
}

// C99 6.5.15p6: If both operands are pointers to compatible types or to
// differently qualified versions of compatible types, the result type is
// a pointer to an appropriately qualified version of the composite
// type.

// Only CVR-qualifiers exist in the standard, and the differently-qualified
// clause doesn't make sense for our extensions. E.g. address space 2 should
// be incompatible with address space 3: they may live on different devices or
// anything.
Qualifiers lhQual = lhptee.getQualifiers();
Qualifiers rhQual = rhptee.getQualifiers();

LangAS ResultAddrSpace = LangAS::Default;
LangAS LAddrSpace = lhQual.getAddressSpace();
LangAS RAddrSpace = rhQual.getAddressSpace();

// OpenCL v1.1 s6.5 - Conversion between pointers to distinct address
// spaces is disallowed.
if (lhQual.isAddressSpaceSupersetOf(rhQual))
  ResultAddrSpace = LAddrSpace;
else if (rhQual.isAddressSpaceSupersetOf(lhQual))
  ResultAddrSpace = RAddrSpace;
else {
  S.Diag(Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
      << LHSTy << RHSTy << 2 << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();
  return QualType();
}

unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
lhQual.removeCVRQualifiers();
rhQual.removeCVRQualifiers();

// OpenCL v2.0 specification doesn't extend compatibility of type qualifiers
// (C99 6.7.3) for address spaces. We assume that the check should behave in
// the same manner as it's defined for CVR qualifiers, so for OpenCL two
// qual types are compatible iff
//  * corresponded types are compatible
//  * CVR qualifiers are equal
//  * address spaces are equal
// Thus for conditional operator we merge CVR and address space unqualified
// pointees and if there is a composite type we return a pointer to it with
// merged qualifiers.
LHSCastKind =
    LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
RHSCastKind =
    RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
lhQual.removeAddressSpace();
rhQual.removeAddressSpace();

lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual);
rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual);

QualType CompositeTy = S.Context.mergeTypes(
    lhptee, rhptee, /*OfBlockPointer=*/false, /*Unqualified=*/false,
    /*BlockReturnType=*/false, /*IsConditionalOperator=*/true);

if (CompositeTy.isNull()) {
  // In this situation, we assume void* type. No especially good
  // reason, but this is what gcc does, and we do have to pick
  // to get a consistent AST.
  QualType incompatTy;
  incompatTy = S.Context.getPointerType(
      S.Context.getAddrSpaceQualType(S.Context.VoidTy, ResultAddrSpace));
  LHS = S.ImpCastExprToType(LHS.get(), incompatTy, LHSCastKind);
  RHS = S.ImpCastExprToType(RHS.get(), incompatTy, RHSCastKind);

  // FIXME: For OpenCL the warning emission and cast to void* leaves a room
  // for casts between types with incompatible address space qualifiers.
  // For the following code the compiler produces casts between global and
  // local address spaces of the corresponded innermost pointees:
  // local int *global *a;
  // global int *global *b;
  // a = (0 ? a : b); // see C99 6.5.16.1.p1.
  S.Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers)
      << LHSTy << RHSTy << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();

  return incompatTy;
}

// The pointer types are compatible.
// In case of OpenCL ResultTy should have the address space qualifier
// which is a superset of address spaces of both the 2nd and the 3rd
// operands of the conditional operator.
QualType ResultTy = [&, ResultAddrSpace]() {
  if (S.getLangOpts().OpenCL) {
    Qualifiers CompositeQuals = CompositeTy.getQualifiers();
    CompositeQuals.setAddressSpace(ResultAddrSpace);
    return S.Context
        .getQualifiedType(CompositeTy.getUnqualifiedType(), CompositeQuals)
        .withCVRQualifiers(MergedCVRQual);
  }
  return CompositeTy.withCVRQualifiers(MergedCVRQual);
}();
if (IsBlockPointer)
  ResultTy = S.Context.getBlockPointerType(ResultTy);
else
  ResultTy = S.Context.getPointerType(ResultTy);

LHS = S.ImpCastExprToType(LHS.get(), ResultTy, LHSCastKind);
RHS = S.ImpCastExprToType(RHS.get(), ResultTy, RHSCastKind);
return ResultTy;
8609}

8611/// Return the resulting type when the operands are both block pointers.
8612static QualType checkConditionalBlockPointerCompatibility(Sema &S,
                                                        ExprResult &LHS,
                                                        ExprResult &RHS,
                                                        SourceLocation Loc) {
QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();

if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
  if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
    QualType destType = S.Context.getPointerType(S.Context.VoidTy);
    LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast);
    RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast);
    return destType;
  }
  S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
    << LHSTy << RHSTy << LHS.get()->getSourceRange()
    << RHS.get()->getSourceRange();
  return QualType();
}

// We have 2 block pointer types.
return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
8634}

8636/// Return the resulting type when the operands are both pointers.
8637static QualType
8638checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
                                          ExprResult &RHS,
                                          SourceLocation Loc) {
// get the pointer types
QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();

// get the "pointed to" types
QualType lhptee = LHSTy->castAs<PointerType>()->getPointeeType();
QualType rhptee = RHSTy->castAs<PointerType>()->getPointeeType();

// ignore qualifiers on void (C99 6.5.15p3, clause 6)
if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
  // Figure out necessary qualifiers (C99 6.5.15p6)
  QualType destPointee
    = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
  QualType destType = S.Context.getPointerType(destPointee);
  // Add qualifiers if necessary.
  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp);
  // Promote to void*.
  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast);
  return destType;
}
if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
  QualType destPointee
    = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
  QualType destType = S.Context.getPointerType(destPointee);
  // Add qualifiers if necessary.
  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp);
  // Promote to void*.
  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast);
  return destType;
}

return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
8673}

8675/// Return false if the first expression is not an integer and the second
8676/// expression is not a pointer, true otherwise.
8677static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int,
                                      Expr* PointerExpr, SourceLocation Loc,
                                      bool IsIntFirstExpr) {
if (!PointerExpr->getType()->isPointerType() ||
    !Int.get()->getType()->isIntegerType())
  return false;

Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();

S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
  << Expr1->getType() << Expr2->getType()
  << Expr1->getSourceRange() << Expr2->getSourceRange();
Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(),
                          CK_IntegralToPointer);
return true;
8693}

8695/// Simple conversion between integer and floating point types.
8696///
8697/// Used when handling the OpenCL conditional operator where the
8698/// condition is a vector while the other operands are scalar.
8699///
8700/// OpenCL v1.1 s6.3.i and s6.11.6 together require that the scalar
8701/// types are either integer or floating type. Between the two
8702/// operands, the type with the higher rank is defined as the "result
8703/// type". The other operand needs to be promoted to the same type. No
8704/// other type promotion is allowed. We cannot use
8705/// UsualArithmeticConversions() for this purpose, since it always
8706/// promotes promotable types.
8707static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
                                          ExprResult &RHS,
                                          SourceLocation QuestionLoc) {
LHS = S.DefaultFunctionArrayLvalueConversion(LHS.get());
if (LHS.isInvalid())
  return QualType();
RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
  return QualType();

// For conversion purposes, we ignore any qualifiers.
// For example, "const float" and "float" are equivalent.
QualType LHSType =
  S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
QualType RHSType =
  S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();

if (!LHSType->isIntegerType() && !LHSType->isRealFloatingType()) {
  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
    << LHSType << LHS.get()->getSourceRange();
  return QualType();
}

if (!RHSType->isIntegerType() && !RHSType->isRealFloatingType()) {
  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
    << RHSType << RHS.get()->getSourceRange();
  return QualType();
}

// If both types are identical, no conversion is needed.
if (LHSType == RHSType)
  return LHSType;

// Now handle "real" floating types (i.e. float, double, long double).
if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
  return handleFloatConversion(S, LHS, RHS, LHSType, RHSType,
                               /*IsCompAssign = */ false);

// Finally, we have two differing integer types.
return handleIntegerConversion<doIntegralCast, doIntegralCast>
(S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
8748}

8750/// Convert scalar operands to a vector that matches the
8751///        condition in length.
8752///
8753/// Used when handling the OpenCL conditional operator where the
8754/// condition is a vector while the other operands are scalar.
8755///
8756/// We first compute the "result type" for the scalar operands
8757/// according to OpenCL v1.1 s6.3.i. Both operands are then converted
8758/// into a vector of that type where the length matches the condition
8759/// vector type. s6.11.6 requires that the element types of the result
8760/// and the condition must have the same number of bits.
8761static QualType
8762OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS,
                            QualType CondTy, SourceLocation QuestionLoc) {
QualType ResTy = OpenCLArithmeticConversions(S, LHS, RHS, QuestionLoc);
if (ResTy.isNull()) return QualType();

const VectorType *CV = CondTy->getAs<VectorType>();
assert(CV)(static_cast <bool> (CV) ? void (0) : __assert_fail ("CV"
, "clang/lib/Sema/SemaExpr.cpp", 8768, __extension__ __PRETTY_FUNCTION__
));

// Determine the vector result type
unsigned NumElements = CV->getNumElements();
QualType VectorTy = S.Context.getExtVectorType(ResTy, NumElements);

// Ensure that all types have the same number of bits
if (S.Context.getTypeSize(CV->getElementType())
    != S.Context.getTypeSize(ResTy)) {
  // Since VectorTy is created internally, it does not pretty print
  // with an OpenCL name. Instead, we just print a description.
  std::string EleTyName = ResTy.getUnqualifiedType().getAsString();
  SmallString<64> Str;
  llvm::raw_svector_ostream OS(Str);
  OS << "(vector of " << NumElements << " '" << EleTyName << "' values)";
  S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
    << CondTy << OS.str();
  return QualType();
}

// Convert operands to the vector result type
LHS = S.ImpCastExprToType(LHS.get(), VectorTy, CK_VectorSplat);
RHS = S.ImpCastExprToType(RHS.get(), VectorTy, CK_VectorSplat);

return VectorTy;
8793}

8795/// Return false if this is a valid OpenCL condition vector
8796static bool checkOpenCLConditionVector(Sema &S, Expr *Cond,
                                     SourceLocation QuestionLoc) {
// OpenCL v1.1 s6.11.6 says the elements of the vector must be of
// integral type.
const VectorType *CondTy = Cond->getType()->getAs<VectorType>();
assert(CondTy)(static_cast <bool> (CondTy) ? void (0) : __assert_fail
 ("CondTy", "clang/lib/Sema/SemaExpr.cpp", 8801, __extension__
 __PRETTY_FUNCTION__));
QualType EleTy = CondTy->getElementType();
if (EleTy->isIntegerType()) return false;

S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
  << Cond->getType() << Cond->getSourceRange();
return true;
8808}

8810/// Return false if the vector condition type and the vector
8811///        result type are compatible.
8812///
8813/// OpenCL v1.1 s6.11.6 requires that both vector types have the same
8814/// number of elements, and their element types have the same number
8815/// of bits.
8816static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
                            SourceLocation QuestionLoc) {
const VectorType *CV = CondTy->getAs<VectorType>();
const VectorType *RV = VecResTy->getAs<VectorType>();
assert(CV && RV)(static_cast <bool> (CV && RV) ? void (0) : __assert_fail
 ("CV && RV", "clang/lib/Sema/SemaExpr.cpp", 8820, __extension__
 __PRETTY_FUNCTION__));

if (CV->getNumElements() != RV->getNumElements()) {
  S.Diag(QuestionLoc, diag::err_conditional_vector_size)
    << CondTy << VecResTy;
  return true;
}

QualType CVE = CV->getElementType();
QualType RVE = RV->getElementType();

if (S.Context.getTypeSize(CVE) != S.Context.getTypeSize(RVE)) {
  S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
    << CondTy << VecResTy;
  return true;
}

return false;
8838}

8840/// Return the resulting type for the conditional operator in
8841///        OpenCL (aka "ternary selection operator", OpenCL v1.1
8842///        s6.3.i) when the condition is a vector type.
8843static QualType
8844OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond,
                           ExprResult &LHS, ExprResult &RHS,
                           SourceLocation QuestionLoc) {
Cond = S.DefaultFunctionArrayLvalueConversion(Cond.get());
if (Cond.isInvalid())
  return QualType();
QualType CondTy = Cond.get()->getType();

if (checkOpenCLConditionVector(S, Cond.get(), QuestionLoc))
  return QualType();

// If either operand is a vector then find the vector type of the
// result as specified in OpenCL v1.1 s6.3.i.
if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType()) {
  bool IsBoolVecLang =
      !S.getLangOpts().OpenCL && !S.getLangOpts().OpenCLCPlusPlus;
  QualType VecResTy =
      S.CheckVectorOperands(LHS, RHS, QuestionLoc,
                            /*isCompAssign*/ false,
                            /*AllowBothBool*/ true,
                            /*AllowBoolConversions*/ false,
                            /*AllowBooleanOperation*/ IsBoolVecLang,
                            /*ReportInvalid*/ true);
  if (VecResTy.isNull())
    return QualType();
  // The result type must match the condition type as specified in
  // OpenCL v1.1 s6.11.6.
  if (checkVectorResult(S, CondTy, VecResTy, QuestionLoc))
    return QualType();
  return VecResTy;
}

// Both operands are scalar.
return OpenCLConvertScalarsToVectors(S, LHS, RHS, CondTy, QuestionLoc);
8879}

8881/// Return true if the Expr is block type
8882static bool checkBlockType(Sema &S, const Expr *E) {
if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
  QualType Ty = CE->getCallee()->getType();
  if (Ty->isBlockPointerType()) {
    S.Diag(E->getExprLoc(), diag::err_opencl_ternary_with_block);
    return true;
  }
}
return false;
8891}

8893/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
8894/// In that case, LHS = cond.
8895/// C99 6.5.15
8896QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
                                      ExprResult &RHS, ExprValueKind &VK,
                                      ExprObjectKind &OK,
                                      SourceLocation QuestionLoc) {

ExprResult LHSResult = CheckPlaceholderExpr(LHS.get());
if (!LHSResult.isUsable()) return QualType();
LHS = LHSResult;

ExprResult RHSResult = CheckPlaceholderExpr(RHS.get());
if (!RHSResult.isUsable()) return QualType();
RHS = RHSResult;

// C++ is sufficiently different to merit its own checker.
if (getLangOpts().CPlusPlus)
  return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);

VK = VK_PRValue;
OK = OK_Ordinary;

if (Context.isDependenceAllowed() &&
    (Cond.get()->isTypeDependent() || LHS.get()->isTypeDependent() ||
     RHS.get()->isTypeDependent())) {
  assert(!getLangOpts().CPlusPlus)(static_cast <bool> (!getLangOpts().CPlusPlus) ? void (
0) : __assert_fail ("!getLangOpts().CPlusPlus", "clang/lib/Sema/SemaExpr.cpp"
, 8919, __extension__ __PRETTY_FUNCTION__));
  assert((Cond.get()->containsErrors() || LHS.get()->containsErrors() ||(static_cast <bool> ((Cond.get()->containsErrors() ||
 LHS.get()->containsErrors() || RHS.get()->containsErrors
()) && "should only occur in error-recovery path.") ?
 void (0) : __assert_fail ("(Cond.get()->containsErrors() || LHS.get()->containsErrors() || RHS.get()->containsErrors()) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 8922, __extension__ __PRETTY_FUNCTION__
))
          RHS.get()->containsErrors()) &&(static_cast <bool> ((Cond.get()->containsErrors() ||
 LHS.get()->containsErrors() || RHS.get()->containsErrors
()) && "should only occur in error-recovery path.") ?
 void (0) : __assert_fail ("(Cond.get()->containsErrors() || LHS.get()->containsErrors() || RHS.get()->containsErrors()) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 8922, __extension__ __PRETTY_FUNCTION__
))
         "should only occur in error-recovery path.")(static_cast <bool> ((Cond.get()->containsErrors() ||
 LHS.get()->containsErrors() || RHS.get()->containsErrors
()) && "should only occur in error-recovery path.") ?
 void (0) : __assert_fail ("(Cond.get()->containsErrors() || LHS.get()->containsErrors() || RHS.get()->containsErrors()) && \"should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 8922, __extension__ __PRETTY_FUNCTION__
));
  return Context.DependentTy;
}

// The OpenCL operator with a vector condition is sufficiently
// different to merit its own checker.
if ((getLangOpts().OpenCL && Cond.get()->getType()->isVectorType()) ||
    Cond.get()->getType()->isExtVectorType())
  return OpenCLCheckVectorConditional(*this, Cond, LHS, RHS, QuestionLoc);

// First, check the condition.
Cond = UsualUnaryConversions(Cond.get());
if (Cond.isInvalid())
  return QualType();
if (checkCondition(*this, Cond.get(), QuestionLoc))
  return QualType();

// Now check the two expressions.
if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType())
  return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/ false,
                             /*AllowBothBool*/ true,
                             /*AllowBoolConversions*/ false,
                             /*AllowBooleanOperation*/ false,
                             /*ReportInvalid*/ true);

QualType ResTy =
    UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();

QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();

// Diagnose attempts to convert between __ibm128, __float128 and long double
// where such conversions currently can't be handled.
if (unsupportedTypeConversion(*this, LHSTy, RHSTy)) {
  Diag(QuestionLoc,
       diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
    << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
  return QualType();
}

// OpenCL v2.0 s6.12.5 - Blocks cannot be used as expressions of the ternary
// selection operator (?:).
if (getLangOpts().OpenCL &&
    ((int)checkBlockType(*this, LHS.get()) | (int)checkBlockType(*this, RHS.get()))) {
  return QualType();
}

// If both operands have arithmetic type, do the usual arithmetic conversions
// to find a common type: C99 6.5.15p3,5.
if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
  // Disallow invalid arithmetic conversions, such as those between bit-
  // precise integers types of different sizes, or between a bit-precise
  // integer and another type.
  if (ResTy.isNull() && (LHSTy->isBitIntType() || RHSTy->isBitIntType())) {
    Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
        << LHSTy << RHSTy << LHS.get()->getSourceRange()
        << RHS.get()->getSourceRange();
    return QualType();
  }

  LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
  RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));

  return ResTy;
}

// And if they're both bfloat (which isn't arithmetic), that's fine too.
if (LHSTy->isBFloat16Type() && RHSTy->isBFloat16Type()) {
  return Context.getCommonSugaredType(LHSTy, RHSTy);
}

// If both operands are the same structure or union type, the result is that
// type.
if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) {    // C99 6.5.15p3
  if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
    if (LHSRT->getDecl() == RHSRT->getDecl())
      // "If both the operands have structure or union type, the result has
      // that type."  This implies that CV qualifiers are dropped.
      return Context.getCommonSugaredType(LHSTy.getUnqualifiedType(),
                                          RHSTy.getUnqualifiedType());
  // FIXME: Type of conditional expression must be complete in C mode.
}

// C99 6.5.15p5: "If both operands have void type, the result has void type."
// The following || allows only one side to be void (a GCC-ism).
if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
  QualType ResTy;
  if (LHSTy->isVoidType() && RHSTy->isVoidType()) {
    ResTy = Context.getCommonSugaredType(LHSTy, RHSTy);
  } else if (RHSTy->isVoidType()) {
    ResTy = RHSTy;
    Diag(RHS.get()->getBeginLoc(), diag::ext_typecheck_cond_one_void)
        << RHS.get()->getSourceRange();
  } else {
    ResTy = LHSTy;
    Diag(LHS.get()->getBeginLoc(), diag::ext_typecheck_cond_one_void)
        << LHS.get()->getSourceRange();
  }
  LHS = ImpCastExprToType(LHS.get(), ResTy, CK_ToVoid);
  RHS = ImpCastExprToType(RHS.get(), ResTy, CK_ToVoid);
  return ResTy;
}

// C2x 6.5.15p7:
//   ... if both the second and third operands have nullptr_t type, the
//   result also has that type.
if (LHSTy->isNullPtrType() && Context.hasSameType(LHSTy, RHSTy))
  return ResTy;

// C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
// the type of the other operand."
if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy;
if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy;

// All objective-c pointer type analysis is done here.
QualType compositeType = FindCompositeObjCPointerType(LHS, RHS,
                                                      QuestionLoc);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();
if (!compositeType.isNull())
  return compositeType;


// Handle block pointer types.
if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType())
  return checkConditionalBlockPointerCompatibility(*this, LHS, RHS,
                                                   QuestionLoc);

// Check constraints for C object pointers types (C99 6.5.15p3,6).
if (LHSTy->isPointerType() && RHSTy->isPointerType())
  return checkConditionalObjectPointersCompatibility(*this, LHS, RHS,
                                                     QuestionLoc);

// GCC compatibility: soften pointer/integer mismatch.  Note that
// null pointers have been filtered out by this point.
if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
    /*IsIntFirstExpr=*/true))
  return RHSTy;
if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
    /*IsIntFirstExpr=*/false))
  return LHSTy;

// Allow ?: operations in which both operands have the same
// built-in sizeless type.
if (LHSTy->isSizelessBuiltinType() && Context.hasSameType(LHSTy, RHSTy))
  return Context.getCommonSugaredType(LHSTy, RHSTy);

// Emit a better diagnostic if one of the expressions is a null pointer
// constant and the other is not a pointer type. In this case, the user most
// likely forgot to take the address of the other expression.
if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
  return QualType();

// Otherwise, the operands are not compatible.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
  << LHSTy << RHSTy << LHS.get()->getSourceRange()
  << RHS.get()->getSourceRange();
return QualType();
9083}

9085/// FindCompositeObjCPointerType - Helper method to find composite type of
9086/// two objective-c pointer types of the two input expressions.
9087QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
                                          SourceLocation QuestionLoc) {
QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();

// Handle things like Class and struct objc_class*.  Here we case the result
// to the pseudo-builtin, because that will be implicitly cast back to the
// redefinition type if an attempt is made to access its fields.
if (LHSTy->isObjCClassType() &&
    (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) {
  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast);
  return LHSTy;
}
if (RHSTy->isObjCClassType() &&
    (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) {
  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast);
  return RHSTy;
}
// And the same for struct objc_object* / id
if (LHSTy->isObjCIdType() &&
    (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) {
  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast);
  return LHSTy;
}
if (RHSTy->isObjCIdType() &&
    (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) {
  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast);
  return RHSTy;
}
// And the same for struct objc_selector* / SEL
if (Context.isObjCSelType(LHSTy) &&
    (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) {
  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_BitCast);
  return LHSTy;
}
if (Context.isObjCSelType(RHSTy) &&
    (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) {
  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_BitCast);
  return RHSTy;
}
// Check constraints for Objective-C object pointers types.
if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) {

  if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
    // Two identical object pointer types are always compatible.
    return LHSTy;
  }
  const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>();
  const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>();
  QualType compositeType = LHSTy;

  // If both operands are interfaces and either operand can be
  // assigned to the other, use that type as the composite
  // type. This allows
  //   xxx ? (A*) a : (B*) b
  // where B is a subclass of A.
  //
  // Additionally, as for assignment, if either type is 'id'
  // allow silent coercion. Finally, if the types are
  // incompatible then make sure to use 'id' as the composite
  // type so the result is acceptable for sending messages to.

  // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
  // It could return the composite type.
  if (!(compositeType =
        Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) {
    // Nothing more to do.
  } else if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) {
    compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy;
  } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) {
    compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy;
  } else if ((LHSOPT->isObjCQualifiedIdType() ||
              RHSOPT->isObjCQualifiedIdType()) &&
             Context.ObjCQualifiedIdTypesAreCompatible(LHSOPT, RHSOPT,
                                                       true)) {
    // Need to handle "id<xx>" explicitly.
    // GCC allows qualified id and any Objective-C type to devolve to
    // id. Currently localizing to here until clear this should be
    // part of ObjCQualifiedIdTypesAreCompatible.
    compositeType = Context.getObjCIdType();
  } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) {
    compositeType = Context.getObjCIdType();
  } else {
    Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
    << LHSTy << RHSTy
    << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
    QualType incompatTy = Context.getObjCIdType();
    LHS = ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast);
    RHS = ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast);
    return incompatTy;
  }
  // The object pointer types are compatible.
  LHS = ImpCastExprToType(LHS.get(), compositeType, CK_BitCast);
  RHS = ImpCastExprToType(RHS.get(), compositeType, CK_BitCast);
  return compositeType;
}
// Check Objective-C object pointer types and 'void *'
if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) {
  if (getLangOpts().ObjCAutoRefCount) {
    // ARC forbids the implicit conversion of object pointers to 'void *',
    // so these types are not compatible.
    Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
        << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
    LHS = RHS = true;
    return QualType();
  }
  QualType lhptee = LHSTy->castAs<PointerType>()->getPointeeType();
  QualType rhptee = RHSTy->castAs<ObjCObjectPointerType>()->getPointeeType();
  QualType destPointee
  = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
  QualType destType = Context.getPointerType(destPointee);
  // Add qualifiers if necessary.
  LHS = ImpCastExprToType(LHS.get(), destType, CK_NoOp);
  // Promote to void*.
  RHS = ImpCastExprToType(RHS.get(), destType, CK_BitCast);
  return destType;
}
if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) {
  if (getLangOpts().ObjCAutoRefCount) {
    // ARC forbids the implicit conversion of object pointers to 'void *',
    // so these types are not compatible.
    Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
        << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
    LHS = RHS = true;
    return QualType();
  }
  QualType lhptee = LHSTy->castAs<ObjCObjectPointerType>()->getPointeeType();
  QualType rhptee = RHSTy->castAs<PointerType>()->getPointeeType();
  QualType destPointee
  = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
  QualType destType = Context.getPointerType(destPointee);
  // Add qualifiers if necessary.
  RHS = ImpCastExprToType(RHS.get(), destType, CK_NoOp);
  // Promote to void*.
  LHS = ImpCastExprToType(LHS.get(), destType, CK_BitCast);
  return destType;
}
return QualType();
9225}

9227/// SuggestParentheses - Emit a note with a fixit hint that wraps
9228/// ParenRange in parentheses.
9229static void SuggestParentheses(Sema &Self, SourceLocation Loc,
                             const PartialDiagnostic &Note,
                             SourceRange ParenRange) {
SourceLocation EndLoc = Self.getLocForEndOfToken(ParenRange.getEnd());
if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() &&
    EndLoc.isValid()) {
  Self.Diag(Loc, Note)
    << FixItHint::CreateInsertion(ParenRange.getBegin(), "(")
    << FixItHint::CreateInsertion(EndLoc, ")");
} else {
  // We can't display the parentheses, so just show the bare note.
  Self.Diag(Loc, Note) << ParenRange;
}
9242}

9244static bool IsArithmeticOp(BinaryOperatorKind Opc) {
return BinaryOperator::isAdditiveOp(Opc) ||
       BinaryOperator::isMultiplicativeOp(Opc) ||
       BinaryOperator::isShiftOp(Opc) || Opc == BO_And || Opc == BO_Or;
// This only checks for bitwise-or and bitwise-and, but not bitwise-xor and
// not any of the logical operators.  Bitwise-xor is commonly used as a
// logical-xor because there is no logical-xor operator.  The logical
// operators, including uses of xor, have a high false positive rate for
// precedence warnings.
9253}

9255/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary
9256/// expression, either using a built-in or overloaded operator,
9257/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side
9258/// expression.
9259static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode,
                                 Expr **RHSExprs) {
// Don't strip parenthesis: we should not warn if E is in parenthesis.
E = E->IgnoreImpCasts();
E = E->IgnoreConversionOperatorSingleStep();
E = E->IgnoreImpCasts();
if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
  E = MTE->getSubExpr();
  E = E->IgnoreImpCasts();
}

// Built-in binary operator.
if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) {
  if (IsArithmeticOp(OP->getOpcode())) {
    *Opcode = OP->getOpcode();
    *RHSExprs = OP->getRHS();
    return true;
  }
}

// Overloaded operator.
if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) {
  if (Call->getNumArgs() != 2)
    return false;

  // Make sure this is really a binary operator that is safe to pass into
  // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
  OverloadedOperatorKind OO = Call->getOperator();
  if (OO < OO_Plus || OO > OO_Arrow ||
      OO == OO_PlusPlus || OO == OO_MinusMinus)
    return false;

  BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO);
  if (IsArithmeticOp(OpKind)) {
    *Opcode = OpKind;
    *RHSExprs = Call->getArg(1);
    return true;
  }
}

return false;
9300}

9302/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
9303/// or is a logical expression such as (x==y) which has int type, but is
9304/// commonly interpreted as boolean.
9305static bool ExprLooksBoolean(Expr *E) {
E = E->IgnoreParenImpCasts();

if (E->getType()->isBooleanType())
  return true;
if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E))
  return OP->isComparisonOp() || OP->isLogicalOp();
if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E))
  return OP->getOpcode() == UO_LNot;
if (E->getType()->isPointerType())
  return true;
// FIXME: What about overloaded operator calls returning "unspecified boolean
// type"s (commonly pointer-to-members)?

return false;
9320}

9322/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator
9323/// and binary operator are mixed in a way that suggests the programmer assumed
9324/// the conditional operator has higher precedence, for example:
9325/// "int x = a + someBinaryCondition ? 1 : 2".
9326static void DiagnoseConditionalPrecedence(Sema &Self,
                                        SourceLocation OpLoc,
                                        Expr *Condition,
                                        Expr *LHSExpr,
                                        Expr *RHSExpr) {
BinaryOperatorKind CondOpcode;
Expr *CondRHS;

if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS))
  return;
if (!ExprLooksBoolean(CondRHS))
  return;

// The condition is an arithmetic binary expression, with a right-
// hand side that looks boolean, so warn.

unsigned DiagID = BinaryOperator::isBitwiseOp(CondOpcode)
                      ? diag::warn_precedence_bitwise_conditional
                      : diag::warn_precedence_conditional;

Self.Diag(OpLoc, DiagID)
    << Condition->getSourceRange()
    << BinaryOperator::getOpcodeStr(CondOpcode);

SuggestParentheses(
    Self, OpLoc,
    Self.PDiag(diag::note_precedence_silence)
        << BinaryOperator::getOpcodeStr(CondOpcode),
    SourceRange(Condition->getBeginLoc(), Condition->getEndLoc()));

SuggestParentheses(Self, OpLoc,
                   Self.PDiag(diag::note_precedence_conditional_first),
                   SourceRange(CondRHS->getBeginLoc(), RHSExpr->getEndLoc()));
9359}

9361/// Compute the nullability of a conditional expression.
9362static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
                                            QualType LHSTy, QualType RHSTy,
                                            ASTContext &Ctx) {
if (!ResTy->isAnyPointerType())
  return ResTy;

auto GetNullability = [](QualType Ty) {
  std::optional<NullabilityKind> Kind = Ty->getNullability();
  if (Kind) {
    // For our purposes, treat _Nullable_result as _Nullable.
    if (*Kind == NullabilityKind::NullableResult)
      return NullabilityKind::Nullable;
    return *Kind;
  }
  return NullabilityKind::Unspecified;
};

auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
NullabilityKind MergedKind;

// Compute nullability of a binary conditional expression.
if (IsBin) {
  if (LHSKind == NullabilityKind::NonNull)
    MergedKind = NullabilityKind::NonNull;
  else
    MergedKind = RHSKind;
// Compute nullability of a normal conditional expression.
} else {
  if (LHSKind == NullabilityKind::Nullable ||
      RHSKind == NullabilityKind::Nullable)
    MergedKind = NullabilityKind::Nullable;
  else if (LHSKind == NullabilityKind::NonNull)
    MergedKind = RHSKind;
  else if (RHSKind == NullabilityKind::NonNull)
    MergedKind = LHSKind;
  else
    MergedKind = NullabilityKind::Unspecified;
}

// Return if ResTy already has the correct nullability.
if (GetNullability(ResTy) == MergedKind)
  return ResTy;

// Strip all nullability from ResTy.
while (ResTy->getNullability())
  ResTy = ResTy.getSingleStepDesugaredType(Ctx);

// Create a new AttributedType with the new nullability kind.
auto NewAttr = AttributedType::getNullabilityAttrKind(MergedKind);
return Ctx.getAttributedType(NewAttr, ResTy, ResTy);
9412}

9414/// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
9415/// in the case of a the GNU conditional expr extension.
9416ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
                                  SourceLocation ColonLoc,
                                  Expr *CondExpr, Expr *LHSExpr,
                                  Expr *RHSExpr) {
if (!Context.isDependenceAllowed()) {
  // C cannot handle TypoExpr nodes in the condition because it
  // doesn't handle dependent types properly, so make sure any TypoExprs have
  // been dealt with before checking the operands.
  ExprResult CondResult = CorrectDelayedTyposInExpr(CondExpr);
  ExprResult LHSResult = CorrectDelayedTyposInExpr(LHSExpr);
  ExprResult RHSResult = CorrectDelayedTyposInExpr(RHSExpr);

  if (!CondResult.isUsable())
    return ExprError();

  if (LHSExpr) {
    if (!LHSResult.isUsable())
      return ExprError();
  }

  if (!RHSResult.isUsable())
    return ExprError();

  CondExpr = CondResult.get();
  LHSExpr = LHSResult.get();
  RHSExpr = RHSResult.get();
}

// If this is the gnu "x ?: y" extension, analyze the types as though the LHS
// was the condition.
OpaqueValueExpr *opaqueValue = nullptr;
Expr *commonExpr = nullptr;
if (!LHSExpr) {
  commonExpr = CondExpr;
  // Lower out placeholder types first.  This is important so that we don't
  // try to capture a placeholder. This happens in few cases in C++; such
  // as Objective-C++'s dictionary subscripting syntax.
  if (commonExpr->hasPlaceholderType()) {
    ExprResult result = CheckPlaceholderExpr(commonExpr);
    if (!result.isUsable()) return ExprError();
    commonExpr = result.get();
  }
  // We usually want to apply unary conversions *before* saving, except
  // in the special case of a C++ l-value conditional.
  if (!(getLangOpts().CPlusPlus
        && !commonExpr->isTypeDependent()
        && commonExpr->getValueKind() == RHSExpr->getValueKind()
        && commonExpr->isGLValue()
        && commonExpr->isOrdinaryOrBitFieldObject()
        && RHSExpr->isOrdinaryOrBitFieldObject()
        && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
    ExprResult commonRes = UsualUnaryConversions(commonExpr);
    if (commonRes.isInvalid())
      return ExprError();
    commonExpr = commonRes.get();
  }

  // If the common expression is a class or array prvalue, materialize it
  // so that we can safely refer to it multiple times.
  if (commonExpr->isPRValue() && (commonExpr->getType()->isRecordType() ||
                                  commonExpr->getType()->isArrayType())) {
    ExprResult MatExpr = TemporaryMaterializationConversion(commonExpr);
    if (MatExpr.isInvalid())
      return ExprError();
    commonExpr = MatExpr.get();
  }

  opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(),
                                              commonExpr->getType(),
                                              commonExpr->getValueKind(),
                                              commonExpr->getObjectKind(),
                                              commonExpr);
  LHSExpr = CondExpr = opaqueValue;
}

QualType LHSTy = LHSExpr->getType(), RHSTy = RHSExpr->getType();
ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
QualType result = CheckConditionalOperands(Cond, LHS, RHS,
                                           VK, OK, QuestionLoc);
if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
    RHS.isInvalid())
  return ExprError();

DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(),
                              RHS.get());

CheckBoolLikeConversion(Cond.get(), QuestionLoc);

result = computeConditionalNullability(result, commonExpr, LHSTy, RHSTy,
                                       Context);

if (!commonExpr)
  return new (Context)
      ConditionalOperator(Cond.get(), QuestionLoc, LHS.get(), ColonLoc,
                          RHS.get(), result, VK, OK);

return new (Context) BinaryConditionalOperator(
    commonExpr, opaqueValue, Cond.get(), LHS.get(), RHS.get(), QuestionLoc,
    ColonLoc, result, VK, OK);
9517}

9519// Check if we have a conversion between incompatible cmse function pointer
9520// types, that is, a conversion between a function pointer with the
9521// cmse_nonsecure_call attribute and one without.
9522static bool IsInvalidCmseNSCallConversion(Sema &S, QualType FromType,
                                        QualType ToType) {
if (const auto *ToFn =
        dyn_cast<FunctionType>(S.Context.getCanonicalType(ToType))) {
  if (const auto *FromFn =
          dyn_cast<FunctionType>(S.Context.getCanonicalType(FromType))) {
    FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
    FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();

    return ToEInfo.getCmseNSCall() != FromEInfo.getCmseNSCall();
  }
}
return false;
9535}

9537// checkPointerTypesForAssignment - This is a very tricky routine (despite
9538// being closely modeled after the C99 spec:-). The odd characteristic of this
9539// routine is it effectively iqnores the qualifiers on the top level pointee.
9540// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
9541// FIXME: add a couple examples in this comment.
9542static Sema::AssignConvertType
9543checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType,
                             SourceLocation Loc) {
assert(LHSType.isCanonical() && "LHS not canonicalized!")(static_cast <bool> (LHSType.isCanonical() && "LHS not canonicalized!"
) ? void (0) : __assert_fail ("LHSType.isCanonical() && \"LHS not canonicalized!\""
, "clang/lib/Sema/SemaExpr.cpp", 9545, __extension__ __PRETTY_FUNCTION__
));
assert(RHSType.isCanonical() && "RHS not canonicalized!")(static_cast <bool> (RHSType.isCanonical() && "RHS not canonicalized!"
) ? void (0) : __assert_fail ("RHSType.isCanonical() && \"RHS not canonicalized!\""
, "clang/lib/Sema/SemaExpr.cpp", 9546, __extension__ __PRETTY_FUNCTION__
));

// get the "pointed to" type (ignoring qualifiers at the top level)
const Type *lhptee, *rhptee;
Qualifiers lhq, rhq;
std::tie(lhptee, lhq) =
    cast<PointerType>(LHSType)->getPointeeType().split().asPair();
std::tie(rhptee, rhq) =
    cast<PointerType>(RHSType)->getPointeeType().split().asPair();

Sema::AssignConvertType ConvTy = Sema::Compatible;

// C99 6.5.16.1p1: This following citation is common to constraints
// 3 & 4 (below). ...and the type *pointed to* by the left has all the
// qualifiers of the type *pointed to* by the right;

// As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay.
if (lhq.getObjCLifetime() != rhq.getObjCLifetime() &&
    lhq.compatiblyIncludesObjCLifetime(rhq)) {
  // Ignore lifetime for further calculation.
  lhq.removeObjCLifetime();
  rhq.removeObjCLifetime();
}

if (!lhq.compatiblyIncludes(rhq)) {
  // Treat address-space mismatches as fatal.
  if (!lhq.isAddressSpaceSupersetOf(rhq))
    return Sema::IncompatiblePointerDiscardsQualifiers;

  // It's okay to add or remove GC or lifetime qualifiers when converting to
  // and from void*.
  else if (lhq.withoutObjCGCAttr().withoutObjCLifetime()
                      .compatiblyIncludes(
                              rhq.withoutObjCGCAttr().withoutObjCLifetime())
           && (lhptee->isVoidType() || rhptee->isVoidType()))
    ; // keep old

  // Treat lifetime mismatches as fatal.
  else if (lhq.getObjCLifetime() != rhq.getObjCLifetime())
    ConvTy = Sema::IncompatiblePointerDiscardsQualifiers;

  // For GCC/MS compatibility, other qualifier mismatches are treated
  // as still compatible in C.
  else ConvTy = Sema::CompatiblePointerDiscardsQualifiers;
}

// C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
// incomplete type and the other is a pointer to a qualified or unqualified
// version of void...
if (lhptee->isVoidType()) {
  if (rhptee->isIncompleteOrObjectType())
    return ConvTy;

  // As an extension, we allow cast to/from void* to function pointer.
  assert(rhptee->isFunctionType())(static_cast <bool> (rhptee->isFunctionType()) ? void
 (0) : __assert_fail ("rhptee->isFunctionType()", "clang/lib/Sema/SemaExpr.cpp"
, 9600, __extension__ __PRETTY_FUNCTION__));
  return Sema::FunctionVoidPointer;
}

if (rhptee->isVoidType()) {
  if (lhptee->isIncompleteOrObjectType())
    return ConvTy;

  // As an extension, we allow cast to/from void* to function pointer.
  assert(lhptee->isFunctionType())(static_cast <bool> (lhptee->isFunctionType()) ? void
 (0) : __assert_fail ("lhptee->isFunctionType()", "clang/lib/Sema/SemaExpr.cpp"
, 9609, __extension__ __PRETTY_FUNCTION__));
  return Sema::FunctionVoidPointer;
}

if (!S.Diags.isIgnored(
        diag::warn_typecheck_convert_incompatible_function_pointer_strict,
        Loc) &&
    RHSType->isFunctionPointerType() && LHSType->isFunctionPointerType() &&
    !S.IsFunctionConversion(RHSType, LHSType, RHSType))
  return Sema::IncompatibleFunctionPointerStrict;

// C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
// unqualified versions of compatible types, ...
QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0);
if (!S.Context.typesAreCompatible(ltrans, rtrans)) {
  // Check if the pointee types are compatible ignoring the sign.
  // We explicitly check for char so that we catch "char" vs
  // "unsigned char" on systems where "char" is unsigned.
  if (lhptee->isCharType())
    ltrans = S.Context.UnsignedCharTy;
  else if (lhptee->hasSignedIntegerRepresentation())
    ltrans = S.Context.getCorrespondingUnsignedType(ltrans);

  if (rhptee->isCharType())
    rtrans = S.Context.UnsignedCharTy;
  else if (rhptee->hasSignedIntegerRepresentation())
    rtrans = S.Context.getCorrespondingUnsignedType(rtrans);

  if (ltrans == rtrans) {
    // Types are compatible ignoring the sign. Qualifier incompatibility
    // takes priority over sign incompatibility because the sign
    // warning can be disabled.
    if (ConvTy != Sema::Compatible)
      return ConvTy;

    return Sema::IncompatiblePointerSign;
  }

  // If we are a multi-level pointer, it's possible that our issue is simply
  // one of qualification - e.g. char ** -> const char ** is not allowed. If
  // the eventual target type is the same and the pointers have the same
  // level of indirection, this must be the issue.
  if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
    do {
      std::tie(lhptee, lhq) =
        cast<PointerType>(lhptee)->getPointeeType().split().asPair();
      std::tie(rhptee, rhq) =
        cast<PointerType>(rhptee)->getPointeeType().split().asPair();

      // Inconsistent address spaces at this point is invalid, even if the
      // address spaces would be compatible.
      // FIXME: This doesn't catch address space mismatches for pointers of
      // different nesting levels, like:
      //   __local int *** a;
      //   int ** b = a;
      // It's not clear how to actually determine when such pointers are
      // invalidly incompatible.
      if (lhq.getAddressSpace() != rhq.getAddressSpace())
        return Sema::IncompatibleNestedPointerAddressSpaceMismatch;

    } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));

    if (lhptee == rhptee)
      return Sema::IncompatibleNestedPointerQualifiers;
  }

  // General pointer incompatibility takes priority over qualifiers.
  if (RHSType->isFunctionPointerType() && LHSType->isFunctionPointerType())
    return Sema::IncompatibleFunctionPointer;
  return Sema::IncompatiblePointer;
}
if (!S.getLangOpts().CPlusPlus &&
    S.IsFunctionConversion(ltrans, rtrans, ltrans))
  return Sema::IncompatibleFunctionPointer;
if (IsInvalidCmseNSCallConversion(S, ltrans, rtrans))
  return Sema::IncompatibleFunctionPointer;
return ConvTy;
9686}

9688/// checkBlockPointerTypesForAssignment - This routine determines whether two
9689/// block pointer types are compatible or whether a block and normal pointer
9690/// are compatible. It is more restrict than comparing two function pointer
9691// types.
9692static Sema::AssignConvertType
9693checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType,
                                  QualType RHSType) {
assert(LHSType.isCanonical() && "LHS not canonicalized!")(static_cast <bool> (LHSType.isCanonical() && "LHS not canonicalized!"
) ? void (0) : __assert_fail ("LHSType.isCanonical() && \"LHS not canonicalized!\""
, "clang/lib/Sema/SemaExpr.cpp", 9695, __extension__ __PRETTY_FUNCTION__
));
assert(RHSType.isCanonical() && "RHS not canonicalized!")(static_cast <bool> (RHSType.isCanonical() && "RHS not canonicalized!"
) ? void (0) : __assert_fail ("RHSType.isCanonical() && \"RHS not canonicalized!\""
, "clang/lib/Sema/SemaExpr.cpp", 9696, __extension__ __PRETTY_FUNCTION__
));

QualType lhptee, rhptee;

// get the "pointed to" type (ignoring qualifiers at the top level)
lhptee = cast<BlockPointerType>(LHSType)->getPointeeType();
rhptee = cast<BlockPointerType>(RHSType)->getPointeeType();

// In C++, the types have to match exactly.
if (S.getLangOpts().CPlusPlus)
  return Sema::IncompatibleBlockPointer;

Sema::AssignConvertType ConvTy = Sema::Compatible;

// For blocks we enforce that qualifiers are identical.
Qualifiers LQuals = lhptee.getLocalQualifiers();
Qualifiers RQuals = rhptee.getLocalQualifiers();
if (S.getLangOpts().OpenCL) {
  LQuals.removeAddressSpace();
  RQuals.removeAddressSpace();
}
if (LQuals != RQuals)
  ConvTy = Sema::CompatiblePointerDiscardsQualifiers;

// FIXME: OpenCL doesn't define the exact compile time semantics for a block
// assignment.
// The current behavior is similar to C++ lambdas. A block might be
// assigned to a variable iff its return type and parameters are compatible
// (C99 6.2.7) with the corresponding return type and parameters of the LHS of
// an assignment. Presumably it should behave in way that a function pointer
// assignment does in C, so for each parameter and return type:
//  * CVR and address space of LHS should be a superset of CVR and address
//  space of RHS.
//  * unqualified types should be compatible.
if (S.getLangOpts().OpenCL) {
  if (!S.Context.typesAreBlockPointerCompatible(
          S.Context.getQualifiedType(LHSType.getUnqualifiedType(), LQuals),
          S.Context.getQualifiedType(RHSType.getUnqualifiedType(), RQuals)))
    return Sema::IncompatibleBlockPointer;
} else if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType))
  return Sema::IncompatibleBlockPointer;

return ConvTy;
9739}

9741/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types
9742/// for assignment compatibility.
9743static Sema::AssignConvertType
9744checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType,
                                 QualType RHSType) {
assert(LHSType.isCanonical() && "LHS was not canonicalized!")(static_cast <bool> (LHSType.isCanonical() && "LHS was not canonicalized!"
) ? void (0) : __assert_fail ("LHSType.isCanonical() && \"LHS was not canonicalized!\""
, "clang/lib/Sema/SemaExpr.cpp", 9746, __extension__ __PRETTY_FUNCTION__
));
assert(RHSType.isCanonical() && "RHS was not canonicalized!")(static_cast <bool> (RHSType.isCanonical() && "RHS was not canonicalized!"
) ? void (0) : __assert_fail ("RHSType.isCanonical() && \"RHS was not canonicalized!\""
, "clang/lib/Sema/SemaExpr.cpp", 9747, __extension__ __PRETTY_FUNCTION__
));

if (LHSType->isObjCBuiltinType()) {
  // Class is not compatible with ObjC object pointers.
  if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() &&
      !RHSType->isObjCQualifiedClassType())
    return Sema::IncompatiblePointer;
  return Sema::Compatible;
}
if (RHSType->isObjCBuiltinType()) {
  if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
      !LHSType->isObjCQualifiedClassType())
    return Sema::IncompatiblePointer;
  return Sema::Compatible;
}
QualType lhptee = LHSType->castAs<ObjCObjectPointerType>()->getPointeeType();
QualType rhptee = RHSType->castAs<ObjCObjectPointerType>()->getPointeeType();

if (!lhptee.isAtLeastAsQualifiedAs(rhptee) &&
    // make an exception for id<P>
    !LHSType->isObjCQualifiedIdType())
  return Sema::CompatiblePointerDiscardsQualifiers;

if (S.Context.typesAreCompatible(LHSType, RHSType))
  return Sema::Compatible;
if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
  return Sema::IncompatibleObjCQualifiedId;
return Sema::IncompatiblePointer;
9775}

9777Sema::AssignConvertType
9778Sema::CheckAssignmentConstraints(SourceLocation Loc,
                               QualType LHSType, QualType RHSType) {
// Fake up an opaque expression.  We don't actually care about what
// cast operations are required, so if CheckAssignmentConstraints
// adds casts to this they'll be wasted, but fortunately that doesn't
// usually happen on valid code.
OpaqueValueExpr RHSExpr(Loc, RHSType, VK_PRValue);
ExprResult RHSPtr = &RHSExpr;
CastKind K;

return CheckAssignmentConstraints(LHSType, RHSPtr, K, /*ConvertRHS=*/false);
9789}

9791/// This helper function returns true if QT is a vector type that has element
9792/// type ElementType.
9793static bool isVector(QualType QT, QualType ElementType) {
if (const VectorType *VT = QT->getAs<VectorType>())
  return VT->getElementType().getCanonicalType() == ElementType;
return false;
9797}

9799/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
9800/// has code to accommodate several GCC extensions when type checking
9801/// pointers. Here are some objectionable examples that GCC considers warnings:
9802///
9803///  int a, *pint;
9804///  short *pshort;
9805///  struct foo *pfoo;
9806///
9807///  pint = pshort; // warning: assignment from incompatible pointer type
9808///  a = pint; // warning: assignment makes integer from pointer without a cast
9809///  pint = a; // warning: assignment makes pointer from integer without a cast
9810///  pint = pfoo; // warning: assignment from incompatible pointer type
9811///
9812/// As a result, the code for dealing with pointers is more complex than the
9813/// C99 spec dictates.
9814///
9815/// Sets 'Kind' for any result kind except Incompatible.
9816Sema::AssignConvertType
9817Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS,
                               CastKind &Kind, bool ConvertRHS) {
QualType RHSType = RHS.get()->getType();
QualType OrigLHSType = LHSType;

// Get canonical types.  We're not formatting these types, just comparing
// them.
LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType();
RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType();

// Common case: no conversion required.
if (LHSType == RHSType) {
  Kind = CK_NoOp;
  return Compatible;
}

// If the LHS has an __auto_type, there are no additional type constraints
// to be worried about.
if (const auto *AT = dyn_cast<AutoType>(LHSType)) {
  if (AT->isGNUAutoType()) {
    Kind = CK_NoOp;
    return Compatible;
  }
}

// If we have an atomic type, try a non-atomic assignment, then just add an
// atomic qualification step.
if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
  Sema::AssignConvertType result =
    CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind);
  if (result != Compatible)
    return result;
  if (Kind != CK_NoOp && ConvertRHS)
    RHS = ImpCastExprToType(RHS.get(), AtomicTy->getValueType(), Kind);
  Kind = CK_NonAtomicToAtomic;
  return Compatible;
}

// If the left-hand side is a reference type, then we are in a
// (rare!) case where we've allowed the use of references in C,
// e.g., as a parameter type in a built-in function. In this case,
// just make sure that the type referenced is compatible with the
// right-hand side type. The caller is responsible for adjusting
// LHSType so that the resulting expression does not have reference
// type.
if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) {
  if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) {
    Kind = CK_LValueBitCast;
    return Compatible;
  }
  return Incompatible;
}

// Allow scalar to ExtVector assignments, and assignments of an ExtVector type
// to the same ExtVector type.
if (LHSType->isExtVectorType()) {
  if (RHSType->isExtVectorType())
    return Incompatible;
  if (RHSType->isArithmeticType()) {
    // CK_VectorSplat does T -> vector T, so first cast to the element type.
    if (ConvertRHS)
      RHS = prepareVectorSplat(LHSType, RHS.get());
    Kind = CK_VectorSplat;
    return Compatible;
  }
}

// Conversions to or from vector type.
if (LHSType->isVectorType() || RHSType->isVectorType()) {
  if (LHSType->isVectorType() && RHSType->isVectorType()) {
    // Allow assignments of an AltiVec vector type to an equivalent GCC
    // vector type and vice versa
    if (Context.areCompatibleVectorTypes(LHSType, RHSType)) {
      Kind = CK_BitCast;
      return Compatible;
    }

    // If we are allowing lax vector conversions, and LHS and RHS are both
    // vectors, the total size only needs to be the same. This is a bitcast;
    // no bits are changed but the result type is different.
    if (isLaxVectorConversion(RHSType, LHSType)) {
      // The default for lax vector conversions with Altivec vectors will
      // change, so if we are converting between vector types where
      // at least one is an Altivec vector, emit a warning.
      if (Context.getTargetInfo().getTriple().isPPC() &&
          anyAltivecTypes(RHSType, LHSType) &&
          !Context.areCompatibleVectorTypes(RHSType, LHSType))
        Diag(RHS.get()->getExprLoc(), diag::warn_deprecated_lax_vec_conv_all)
            << RHSType << LHSType;
      Kind = CK_BitCast;
      return IncompatibleVectors;
    }
  }

  // When the RHS comes from another lax conversion (e.g. binops between
  // scalars and vectors) the result is canonicalized as a vector. When the
  // LHS is also a vector, the lax is allowed by the condition above. Handle
  // the case where LHS is a scalar.
  if (LHSType->isScalarType()) {
    const VectorType *VecType = RHSType->getAs<VectorType>();
    if (VecType && VecType->getNumElements() == 1 &&
        isLaxVectorConversion(RHSType, LHSType)) {
      if (Context.getTargetInfo().getTriple().isPPC() &&
          (VecType->getVectorKind() == VectorType::AltiVecVector ||
           VecType->getVectorKind() == VectorType::AltiVecBool ||
           VecType->getVectorKind() == VectorType::AltiVecPixel))
        Diag(RHS.get()->getExprLoc(), diag::warn_deprecated_lax_vec_conv_all)
            << RHSType << LHSType;
      ExprResult *VecExpr = &RHS;
      *VecExpr = ImpCastExprToType(VecExpr->get(), LHSType, CK_BitCast);
      Kind = CK_BitCast;
      return Compatible;
    }
  }

  // Allow assignments between fixed-length and sizeless SVE vectors.
  if ((LHSType->isSVESizelessBuiltinType() && RHSType->isVectorType()) ||
      (LHSType->isVectorType() && RHSType->isSVESizelessBuiltinType()))
    if (Context.areCompatibleSveTypes(LHSType, RHSType) ||
        Context.areLaxCompatibleSveTypes(LHSType, RHSType)) {
      Kind = CK_BitCast;
      return Compatible;
    }

  // Allow assignments between fixed-length and sizeless RVV vectors.
  if ((LHSType->isRVVSizelessBuiltinType() && RHSType->isVectorType()) ||
      (LHSType->isVectorType() && RHSType->isRVVSizelessBuiltinType())) {
    if (Context.areCompatibleRVVTypes(LHSType, RHSType) ||
        Context.areLaxCompatibleRVVTypes(LHSType, RHSType)) {
      Kind = CK_BitCast;
      return Compatible;
    }
  }

  return Incompatible;
}

// Diagnose attempts to convert between __ibm128, __float128 and long double
// where such conversions currently can't be handled.
if (unsupportedTypeConversion(*this, LHSType, RHSType))
  return Incompatible;

// Disallow assigning a _Complex to a real type in C++ mode since it simply
// discards the imaginary part.
if (getLangOpts().CPlusPlus && RHSType->getAs<ComplexType>() &&
    !LHSType->getAs<ComplexType>())
  return Incompatible;

// Arithmetic conversions.
if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
    !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
  if (ConvertRHS)
    Kind = PrepareScalarCast(RHS, LHSType);
  return Compatible;
}

// Conversions to normal pointers.
if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
  // U* -> T*
  if (isa<PointerType>(RHSType)) {
    LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
    LangAS AddrSpaceR = RHSType->getPointeeType().getAddressSpace();
    if (AddrSpaceL != AddrSpaceR)
      Kind = CK_AddressSpaceConversion;
    else if (Context.hasCvrSimilarType(RHSType, LHSType))
      Kind = CK_NoOp;
    else
      Kind = CK_BitCast;
    return checkPointerTypesForAssignment(*this, LHSType, RHSType,
                                          RHS.get()->getBeginLoc());
  }

  // int -> T*
  if (RHSType->isIntegerType()) {
    Kind = CK_IntegralToPointer; // FIXME: null?
    return IntToPointer;
  }

  // C pointers are not compatible with ObjC object pointers,
  // with two exceptions:
  if (isa<ObjCObjectPointerType>(RHSType)) {
    //  - conversions to void*
    if (LHSPointer->getPointeeType()->isVoidType()) {
      Kind = CK_BitCast;
      return Compatible;
    }

    //  - conversions from 'Class' to the redefinition type
    if (RHSType->isObjCClassType() &&
        Context.hasSameType(LHSType,
                            Context.getObjCClassRedefinitionType())) {
      Kind = CK_BitCast;
      return Compatible;
    }

    Kind = CK_BitCast;
    return IncompatiblePointer;
  }

  // U^ -> void*
  if (RHSType->getAs<BlockPointerType>()) {
    if (LHSPointer->getPointeeType()->isVoidType()) {
      LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
      LangAS AddrSpaceR = RHSType->getAs<BlockPointerType>()
                              ->getPointeeType()
                              .getAddressSpace();
      Kind =
          AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
      return Compatible;
    }
  }

  return Incompatible;
}

// Conversions to block pointers.
if (isa<BlockPointerType>(LHSType)) {
  // U^ -> T^
  if (RHSType->isBlockPointerType()) {
    LangAS AddrSpaceL = LHSType->getAs<BlockPointerType>()
                            ->getPointeeType()
                            .getAddressSpace();
    LangAS AddrSpaceR = RHSType->getAs<BlockPointerType>()
                            ->getPointeeType()
                            .getAddressSpace();
    Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
    return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType);
  }

  // int or null -> T^
  if (RHSType->isIntegerType()) {
    Kind = CK_IntegralToPointer; // FIXME: null
    return IntToBlockPointer;
  }

  // id -> T^
  if (getLangOpts().ObjC && RHSType->isObjCIdType()) {
    Kind = CK_AnyPointerToBlockPointerCast;
    return Compatible;
  }

  // void* -> T^
  if (const PointerType *RHSPT = RHSType->getAs<PointerType>())
    if (RHSPT->getPointeeType()->isVoidType()) {
      Kind = CK_AnyPointerToBlockPointerCast;
      return Compatible;
    }

  return Incompatible;
}

// Conversions to Objective-C pointers.
if (isa<ObjCObjectPointerType>(LHSType)) {
  // A* -> B*
  if (RHSType->isObjCObjectPointerType()) {
    Kind = CK_BitCast;
    Sema::AssignConvertType result =
      checkObjCPointerTypesForAssignment(*this, LHSType, RHSType);
    if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
        result == Compatible &&
        !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
      result = IncompatibleObjCWeakRef;
    return result;
  }

  // int or null -> A*
  if (RHSType->isIntegerType()) {
    Kind = CK_IntegralToPointer; // FIXME: null
    return IntToPointer;
  }

  // In general, C pointers are not compatible with ObjC object pointers,
  // with two exceptions:
  if (isa<PointerType>(RHSType)) {
    Kind = CK_CPointerToObjCPointerCast;

    //  - conversions from 'void*'
    if (RHSType->isVoidPointerType()) {
      return Compatible;
    }

    //  - conversions to 'Class' from its redefinition type
    if (LHSType->isObjCClassType() &&
        Context.hasSameType(RHSType,
                            Context.getObjCClassRedefinitionType())) {
      return Compatible;
    }

    return IncompatiblePointer;
  }

  // Only under strict condition T^ is compatible with an Objective-C pointer.
  if (RHSType->isBlockPointerType() &&
      LHSType->isBlockCompatibleObjCPointerType(Context)) {
    if (ConvertRHS)
      maybeExtendBlockObject(RHS);
    Kind = CK_BlockPointerToObjCPointerCast;
    return Compatible;
  }

  return Incompatible;
}

// Conversion to nullptr_t (C2x only)
if (getLangOpts().C2x && LHSType->isNullPtrType() &&
    RHS.get()->isNullPointerConstant(Context,
                                     Expr::NPC_ValueDependentIsNull)) {
  // null -> nullptr_t
  Kind = CK_NullToPointer;
  return Compatible;
}

// Conversions from pointers that are not covered by the above.
if (isa<PointerType>(RHSType)) {
  // T* -> _Bool
  if (LHSType == Context.BoolTy) {
    Kind = CK_PointerToBoolean;
    return Compatible;
  }

  // T* -> int
  if (LHSType->isIntegerType()) {
    Kind = CK_PointerToIntegral;
    return PointerToInt;
  }

  return Incompatible;
}

// Conversions from Objective-C pointers that are not covered by the above.
if (isa<ObjCObjectPointerType>(RHSType)) {
  // T* -> _Bool
  if (LHSType == Context.BoolTy) {
    Kind = CK_PointerToBoolean;
    return Compatible;
  }

  // T* -> int
  if (LHSType->isIntegerType()) {
    Kind = CK_PointerToIntegral;
    return PointerToInt;
  }

  return Incompatible;
}

// struct A -> struct B
if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
  if (Context.typesAreCompatible(LHSType, RHSType)) {
    Kind = CK_NoOp;
    return Compatible;
  }
}

if (LHSType->isSamplerT() && RHSType->isIntegerType()) {
  Kind = CK_IntToOCLSampler;
  return Compatible;
}

return Incompatible;
10177}

10179/// Constructs a transparent union from an expression that is
10180/// used to initialize the transparent union.
10181static void ConstructTransparentUnion(Sema &S, ASTContext &C,
                                    ExprResult &EResult, QualType UnionType,
                                    FieldDecl *Field) {
// Build an initializer list that designates the appropriate member
// of the transparent union.
Expr *E = EResult.get();
InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(),
                                                 E, SourceLocation());
Initializer->setType(UnionType);
Initializer->setInitializedFieldInUnion(Field);

// Build a compound literal constructing a value of the transparent
// union type from this initializer list.
TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType);
EResult = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType,
                                      VK_PRValue, Initializer, false);
10197}

10199Sema::AssignConvertType
10200Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType,
                                             ExprResult &RHS) {
QualType RHSType = RHS.get()->getType();

// If the ArgType is a Union type, we want to handle a potential
// transparent_union GCC extension.
const RecordType *UT = ArgType->getAsUnionType();
if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
  return Incompatible;

// The field to initialize within the transparent union.
RecordDecl *UD = UT->getDecl();
FieldDecl *InitField = nullptr;
// It's compatible if the expression matches any of the fields.
for (auto *it : UD->fields()) {
  if (it->getType()->isPointerType()) {
    // If the transparent union contains a pointer type, we allow:
    // 1) void pointer
    // 2) null pointer constant
    if (RHSType->isPointerType())
      if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
        RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast);
        InitField = it;
        break;
      }

    if (RHS.get()->isNullPointerConstant(Context,
                                         Expr::NPC_ValueDependentIsNull)) {
      RHS = ImpCastExprToType(RHS.get(), it->getType(),
                              CK_NullToPointer);
      InitField = it;
      break;
    }
  }

  CastKind Kind;
  if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
        == Compatible) {
    RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind);
    InitField = it;
    break;
  }
}

if (!InitField)
  return Incompatible;

ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField);
return Compatible;
10249}

10251Sema::AssignConvertType
10252Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &CallerRHS,
                                     bool Diagnose,
                                     bool DiagnoseCFAudited,
                                     bool ConvertRHS) {
// We need to be able to tell the caller whether we diagnosed a problem, if
// they ask us to issue diagnostics.
assert((ConvertRHS || !Diagnose) && "can't indicate whether we diagnosed")(static_cast <bool> ((ConvertRHS || !Diagnose) &&
 "can't indicate whether we diagnosed") ? void (0) : __assert_fail
 ("(ConvertRHS || !Diagnose) && \"can't indicate whether we diagnosed\""
, "clang/lib/Sema/SemaExpr.cpp", 10258, __extension__ __PRETTY_FUNCTION__
));

// If ConvertRHS is false, we want to leave the caller's RHS untouched. Sadly,
// we can't avoid *all* modifications at the moment, so we need some somewhere
// to put the updated value.
ExprResult LocalRHS = CallerRHS;
ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;

if (const auto *LHSPtrType = LHSType->getAs<PointerType>()) {
  if (const auto *RHSPtrType = RHS.get()->getType()->getAs<PointerType>()) {
    if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
        !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
      Diag(RHS.get()->getExprLoc(),
           diag::warn_noderef_to_dereferenceable_pointer)
          << RHS.get()->getSourceRange();
    }
  }
}

if (getLangOpts().CPlusPlus) {
  if (!LHSType->isRecordType() && !LHSType->isAtomicType()) {
    // C++ 5.17p3: If the left operand is not of class type, the
    // expression is implicitly converted (C++ 4) to the
    // cv-unqualified type of the left operand.
    QualType RHSType = RHS.get()->getType();
    if (Diagnose) {
      RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
                                      AA_Assigning);
    } else {
      ImplicitConversionSequence ICS =
          TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
                                /*SuppressUserConversions=*/false,
                                AllowedExplicit::None,
                                /*InOverloadResolution=*/false,
                                /*CStyle=*/false,
                                /*AllowObjCWritebackConversion=*/false);
      if (ICS.isFailure())
        return Incompatible;
      RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
                                      ICS, AA_Assigning);
    }
    if (RHS.isInvalid())
      return Incompatible;
    Sema::AssignConvertType result = Compatible;
    if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
        !CheckObjCARCUnavailableWeakConversion(LHSType, RHSType))
      result = IncompatibleObjCWeakRef;
    return result;
  }

  // FIXME: Currently, we fall through and treat C++ classes like C
  // structures.
  // FIXME: We also fall through for atomics; not sure what should
  // happen there, though.
} else if (RHS.get()->getType() == Context.OverloadTy) {
  // As a set of extensions to C, we support overloading on functions. These
  // functions need to be resolved here.
  DeclAccessPair DAP;
  if (FunctionDecl *FD = ResolveAddressOfOverloadedFunction(
          RHS.get(), LHSType, /*Complain=*/false, DAP))
    RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD);
  else
    return Incompatible;
}

// This check seems unnatural, however it is necessary to ensure the proper
// conversion of functions/arrays. If the conversion were done for all
// DeclExpr's (created by ActOnIdExpression), it would mess up the unary
// expressions that suppress this implicit conversion (&, sizeof). This needs
// to happen before we check for null pointer conversions because C does not
// undergo the same implicit conversions as C++ does above (by the calls to
// TryImplicitConversion() and PerformImplicitConversion()) which insert the
// lvalue to rvalue cast before checking for null pointer constraints. This
// addresses code like: nullptr_t val; int *ptr; ptr = val;
//
// Suppress this for references: C++ 8.5.3p5.
if (!LHSType->isReferenceType()) {
  // FIXME: We potentially allocate here even if ConvertRHS is false.
  RHS = DefaultFunctionArrayLvalueConversion(RHS.get(), Diagnose);
  if (RHS.isInvalid())
    return Incompatible;
}

// The constraints are expressed in terms of the atomic, qualified, or
// unqualified type of the LHS.
QualType LHSTypeAfterConversion = LHSType.getAtomicUnqualifiedType();

// C99 6.5.16.1p1: the left operand is a pointer and the right is
// a null pointer constant <C2x>or its type is nullptr_t;</C2x>.
if ((LHSTypeAfterConversion->isPointerType() ||
     LHSTypeAfterConversion->isObjCObjectPointerType() ||
     LHSTypeAfterConversion->isBlockPointerType()) &&
    ((getLangOpts().C2x && RHS.get()->getType()->isNullPtrType()) ||
     RHS.get()->isNullPointerConstant(Context,
                                      Expr::NPC_ValueDependentIsNull))) {
  if (Diagnose || ConvertRHS) {
    CastKind Kind;
    CXXCastPath Path;
    CheckPointerConversion(RHS.get(), LHSType, Kind, Path,
                           /*IgnoreBaseAccess=*/false, Diagnose);
    if (ConvertRHS)
      RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_PRValue, &Path);
  }
  return Compatible;
}
// C2x 6.5.16.1p1: the left operand has type atomic, qualified, or
// unqualified bool, and the right operand is a pointer or its type is
// nullptr_t.
if (getLangOpts().C2x && LHSType->isBooleanType() &&
    RHS.get()->getType()->isNullPtrType()) {
  // NB: T* -> _Bool is handled in CheckAssignmentConstraints, this only
  // only handles nullptr -> _Bool due to needing an extra conversion
  // step.
  // We model this by converting from nullptr -> void * and then let the
  // conversion from void * -> _Bool happen naturally.
  if (Diagnose || ConvertRHS) {
    CastKind Kind;
    CXXCastPath Path;
    CheckPointerConversion(RHS.get(), Context.VoidPtrTy, Kind, Path,
                           /*IgnoreBaseAccess=*/false, Diagnose);
    if (ConvertRHS)
      RHS = ImpCastExprToType(RHS.get(), Context.VoidPtrTy, Kind, VK_PRValue,
                              &Path);
  }
}

// OpenCL queue_t type assignment.
if (LHSType->isQueueT() && RHS.get()->isNullPointerConstant(
                               Context, Expr::NPC_ValueDependentIsNull)) {
  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
  return Compatible;
}

CastKind Kind;
Sema::AssignConvertType result =
  CheckAssignmentConstraints(LHSType, RHS, Kind, ConvertRHS);

// C99 6.5.16.1p2: The value of the right operand is converted to the
// type of the assignment expression.
// CheckAssignmentConstraints allows the left-hand side to be a reference,
// so that we can use references in built-in functions even in C.
// The getNonReferenceType() call makes sure that the resulting expression
// does not have reference type.
if (result != Incompatible && RHS.get()->getType() != LHSType) {
  QualType Ty = LHSType.getNonLValueExprType(Context);
  Expr *E = RHS.get();

  // Check for various Objective-C errors. If we are not reporting
  // diagnostics and just checking for errors, e.g., during overload
  // resolution, return Incompatible to indicate the failure.
  if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
      CheckObjCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion,
                          Diagnose, DiagnoseCFAudited) != ACR_okay) {
    if (!Diagnose)
      return Incompatible;
  }
  if (getLangOpts().ObjC &&
      (CheckObjCBridgeRelatedConversions(E->getBeginLoc(), LHSType,
                                         E->getType(), E, Diagnose) ||
       CheckConversionToObjCLiteral(LHSType, E, Diagnose))) {
    if (!Diagnose)
      return Incompatible;
    // Replace the expression with a corrected version and continue so we
    // can find further errors.
    RHS = E;
    return Compatible;
  }

  if (ConvertRHS)
    RHS = ImpCastExprToType(E, Ty, Kind);
}

return result;
10431}

10433namespace {
10434/// The original operand to an operator, prior to the application of the usual
10435/// arithmetic conversions and converting the arguments of a builtin operator
10436/// candidate.
10437struct OriginalOperand {
explicit OriginalOperand(Expr *Op) : Orig(Op), Conversion(nullptr) {
  if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
    Op = MTE->getSubExpr();
  if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
    Op = BTE->getSubExpr();
  if (auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
    Orig = ICE->getSubExprAsWritten();
    Conversion = ICE->getConversionFunction();
  }
}

QualType getType() const { return Orig->getType(); }

Expr *Orig;
NamedDecl *Conversion;
10453};
10454}

10456QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS,
                             ExprResult &RHS) {
OriginalOperand OrigLHS(LHS.get()), OrigRHS(RHS.get());

Diag(Loc, diag::err_typecheck_invalid_operands)
  << OrigLHS.getType() << OrigRHS.getType()
  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();

// If a user-defined conversion was applied to either of the operands prior
// to applying the built-in operator rules, tell the user about it.
if (OrigLHS.Conversion) {
  Diag(OrigLHS.Conversion->getLocation(),
       diag::note_typecheck_invalid_operands_converted)
    << 0 << LHS.get()->getType();
}
if (OrigRHS.Conversion) {
  Diag(OrigRHS.Conversion->getLocation(),
       diag::note_typecheck_invalid_operands_converted)
    << 1 << RHS.get()->getType();
}

return QualType();
10478}

10480// Diagnose cases where a scalar was implicitly converted to a vector and
10481// diagnose the underlying types. Otherwise, diagnose the error
10482// as invalid vector logical operands for non-C++ cases.
10483QualType Sema::InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
                                          ExprResult &RHS) {
QualType LHSType = LHS.get()->IgnoreImpCasts()->getType();
QualType RHSType = RHS.get()->IgnoreImpCasts()->getType();

bool LHSNatVec = LHSType->isVectorType();
bool RHSNatVec = RHSType->isVectorType();

if (!(LHSNatVec && RHSNatVec)) {
  Expr *Vector = LHSNatVec ? LHS.get() : RHS.get();
  Expr *NonVector = !LHSNatVec ? LHS.get() : RHS.get();
  Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
      << 0 << Vector->getType() << NonVector->IgnoreImpCasts()->getType()
      << Vector->getSourceRange();
  return QualType();
}

Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
    << 1 << LHSType << RHSType << LHS.get()->getSourceRange()
    << RHS.get()->getSourceRange();

return QualType();
10505}

10507/// Try to convert a value of non-vector type to a vector type by converting
10508/// the type to the element type of the vector and then performing a splat.
10509/// If the language is OpenCL, we only use conversions that promote scalar
10510/// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
10511/// for float->int.
10512///
10513/// OpenCL V2.0 6.2.6.p2:
10514/// An error shall occur if any scalar operand type has greater rank
10515/// than the type of the vector element.
10516///
10517/// \param scalar - if non-null, actually perform the conversions
10518/// \return true if the operation fails (but without diagnosing the failure)
10519static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
                                   QualType scalarTy,
                                   QualType vectorEltTy,
                                   QualType vectorTy,
                                   unsigned &DiagID) {
// The conversion to apply to the scalar before splatting it,
// if necessary.
CastKind scalarCast = CK_NoOp;

if (vectorEltTy->isIntegralType(S.Context)) {
  if (S.getLangOpts().OpenCL && (scalarTy->isRealFloatingType() ||
      (scalarTy->isIntegerType() &&
       S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0))) {
    DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
    return true;
  }
  if (!scalarTy->isIntegralType(S.Context))
    return true;
  scalarCast = CK_IntegralCast;
} else if (vectorEltTy->isRealFloatingType()) {
  if (scalarTy->isRealFloatingType()) {
    if (S.getLangOpts().OpenCL &&
        S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) < 0) {
      DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
      return true;
    }
    scalarCast = CK_FloatingCast;
  }
  else if (scalarTy->isIntegralType(S.Context))
    scalarCast = CK_IntegralToFloating;
  else
    return true;
} else {
  return true;
}

// Adjust scalar if desired.
if (scalar) {
  if (scalarCast != CK_NoOp)
    *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast);
  *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat);
}
return false;
10562}

10564/// Convert vector E to a vector with the same number of elements but different
10565/// element type.
10566static ExprResult convertVector(Expr *E, QualType ElementType, Sema &S) {
const auto *VecTy = E->getType()->getAs<VectorType>();
assert(VecTy && "Expression E must be a vector")(static_cast <bool> (VecTy && "Expression E must be a vector"
) ? void (0) : __assert_fail ("VecTy && \"Expression E must be a vector\""
, "clang/lib/Sema/SemaExpr.cpp", 10568, __extension__ __PRETTY_FUNCTION__
));
QualType NewVecTy =
    VecTy->isExtVectorType()
        ? S.Context.getExtVectorType(ElementType, VecTy->getNumElements())
        : S.Context.getVectorType(ElementType, VecTy->getNumElements(),
                                  VecTy->getVectorKind());

// Look through the implicit cast. Return the subexpression if its type is
// NewVecTy.
if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
  if (ICE->getSubExpr()->getType() == NewVecTy)
    return ICE->getSubExpr();

auto Cast = ElementType->isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
return S.ImpCastExprToType(E, NewVecTy, Cast);
10583}

10585/// Test if a (constant) integer Int can be casted to another integer type
10586/// IntTy without losing precision.
10587static bool canConvertIntToOtherIntTy(Sema &S, ExprResult *Int,
                                    QualType OtherIntTy) {
QualType IntTy = Int->get()->getType().getUnqualifiedType();

// Reject cases where the value of the Int is unknown as that would
// possibly cause truncation, but accept cases where the scalar can be
// demoted without loss of precision.
Expr::EvalResult EVResult;
bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.Context);
int Order = S.Context.getIntegerTypeOrder(OtherIntTy, IntTy);
bool IntSigned = IntTy->hasSignedIntegerRepresentation();
bool OtherIntSigned = OtherIntTy->hasSignedIntegerRepresentation();

if (CstInt) {
  // If the scalar is constant and is of a higher order and has more active
  // bits that the vector element type, reject it.
  llvm::APSInt Result = EVResult.Val.getInt();
  unsigned NumBits = IntSigned
                         ? (Result.isNegative() ? Result.getSignificantBits()
                                                : Result.getActiveBits())
                         : Result.getActiveBits();
  if (Order < 0 && S.Context.getIntWidth(OtherIntTy) < NumBits)
    return true;

  // If the signedness of the scalar type and the vector element type
  // differs and the number of bits is greater than that of the vector
  // element reject it.
  return (IntSigned != OtherIntSigned &&
          NumBits > S.Context.getIntWidth(OtherIntTy));
}

// Reject cases where the value of the scalar is not constant and it's
// order is greater than that of the vector element type.
return (Order < 0);
10621}

10623/// Test if a (constant) integer Int can be casted to floating point type
10624/// FloatTy without losing precision.
10625static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int,
                                   QualType FloatTy) {
QualType IntTy = Int->get()->getType().getUnqualifiedType();

// Determine if the integer constant can be expressed as a floating point
// number of the appropriate type.
Expr::EvalResult EVResult;
bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.Context);

uint64_t Bits = 0;
if (CstInt) {
  // Reject constants that would be truncated if they were converted to
  // the floating point type. Test by simple to/from conversion.
  // FIXME: Ideally the conversion to an APFloat and from an APFloat
  //        could be avoided if there was a convertFromAPInt method
  //        which could signal back if implicit truncation occurred.
  llvm::APSInt Result = EVResult.Val.getInt();
  llvm::APFloat Float(S.Context.getFloatTypeSemantics(FloatTy));
  Float.convertFromAPInt(Result, IntTy->hasSignedIntegerRepresentation(),
                         llvm::APFloat::rmTowardZero);
  llvm::APSInt ConvertBack(S.Context.getIntWidth(IntTy),
                           !IntTy->hasSignedIntegerRepresentation());
  bool Ignored = false;
  Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
                         &Ignored);
  if (Result != ConvertBack)
    return true;
} else {
  // Reject types that cannot be fully encoded into the mantissa of
  // the float.
  Bits = S.Context.getTypeSize(IntTy);
  unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
      S.Context.getFloatTypeSemantics(FloatTy));
  if (Bits > FloatPrec)
    return true;
}

return false;
10663}

10665/// Attempt to convert and splat Scalar into a vector whose types matches
10666/// Vector following GCC conversion rules. The rule is that implicit
10667/// conversion can occur when Scalar can be casted to match Vector's element
10668/// type without causing truncation of Scalar.
10669static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar,
                                      ExprResult *Vector) {
QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
QualType VectorTy = Vector->get()->getType().getUnqualifiedType();
QualType VectorEltTy;

if (const auto *VT = VectorTy->getAs<VectorType>()) {
  assert(!isa<ExtVectorType>(VT) &&(static_cast <bool> (!isa<ExtVectorType>(VT) &&
 "ExtVectorTypes should not be handled here!") ? void (0) : __assert_fail
 ("!isa<ExtVectorType>(VT) && \"ExtVectorTypes should not be handled here!\""
, "clang/lib/Sema/SemaExpr.cpp", 10677, __extension__ __PRETTY_FUNCTION__
))
         "ExtVectorTypes should not be handled here!")(static_cast <bool> (!isa<ExtVectorType>(VT) &&
 "ExtVectorTypes should not be handled here!") ? void (0) : __assert_fail
 ("!isa<ExtVectorType>(VT) && \"ExtVectorTypes should not be handled here!\""
, "clang/lib/Sema/SemaExpr.cpp", 10677, __extension__ __PRETTY_FUNCTION__
));
  VectorEltTy = VT->getElementType();
} else if (VectorTy->isVLSTBuiltinType()) {
  VectorEltTy =
      VectorTy->castAs<BuiltinType>()->getSveEltType(S.getASTContext());
} else {
  llvm_unreachable("Only Fixed-Length and SVE Vector types are handled here")::llvm::llvm_unreachable_internal("Only Fixed-Length and SVE Vector types are handled here"
, "clang/lib/Sema/SemaExpr.cpp", 10683);
}

// Reject cases where the vector element type or the scalar element type are
// not integral or floating point types.
if (!VectorEltTy->isArithmeticType() || !ScalarTy->isArithmeticType())
  return true;

// The conversion to apply to the scalar before splatting it,
// if necessary.
CastKind ScalarCast = CK_NoOp;

// Accept cases where the vector elements are integers and the scalar is
// an integer.
// FIXME: Notionally if the scalar was a floating point value with a precise
//        integral representation, we could cast it to an appropriate integer
//        type and then perform the rest of the checks here. GCC will perform
//        this conversion in some cases as determined by the input language.
//        We should accept it on a language independent basis.
if (VectorEltTy->isIntegralType(S.Context) &&
    ScalarTy->isIntegralType(S.Context) &&
    S.Context.getIntegerTypeOrder(VectorEltTy, ScalarTy)) {

  if (canConvertIntToOtherIntTy(S, Scalar, VectorEltTy))
    return true;

  ScalarCast = CK_IntegralCast;
} else if (VectorEltTy->isIntegralType(S.Context) &&
           ScalarTy->isRealFloatingType()) {
  if (S.Context.getTypeSize(VectorEltTy) == S.Context.getTypeSize(ScalarTy))
    ScalarCast = CK_FloatingToIntegral;
  else
    return true;
} else if (VectorEltTy->isRealFloatingType()) {
  if (ScalarTy->isRealFloatingType()) {

    // Reject cases where the scalar type is not a constant and has a higher
    // Order than the vector element type.
    llvm::APFloat Result(0.0);

    // Determine whether this is a constant scalar. In the event that the
    // value is dependent (and thus cannot be evaluated by the constant
    // evaluator), skip the evaluation. This will then diagnose once the
    // expression is instantiated.
    bool CstScalar = Scalar->get()->isValueDependent() ||
                     Scalar->get()->EvaluateAsFloat(Result, S.Context);
    int Order = S.Context.getFloatingTypeOrder(VectorEltTy, ScalarTy);
    if (!CstScalar && Order < 0)
      return true;

    // If the scalar cannot be safely casted to the vector element type,
    // reject it.
    if (CstScalar) {
      bool Truncated = false;
      Result.convert(S.Context.getFloatTypeSemantics(VectorEltTy),
                     llvm::APFloat::rmNearestTiesToEven, &Truncated);
      if (Truncated)
        return true;
    }

    ScalarCast = CK_FloatingCast;
  } else if (ScalarTy->isIntegralType(S.Context)) {
    if (canConvertIntTyToFloatTy(S, Scalar, VectorEltTy))
      return true;

    ScalarCast = CK_IntegralToFloating;
  } else
    return true;
} else if (ScalarTy->isEnumeralType())
  return true;

// Adjust scalar if desired.
if (Scalar) {
  if (ScalarCast != CK_NoOp)
    *Scalar = S.ImpCastExprToType(Scalar->get(), VectorEltTy, ScalarCast);
  *Scalar = S.ImpCastExprToType(Scalar->get(), VectorTy, CK_VectorSplat);
}
return false;
10761}

10763QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                 SourceLocation Loc, bool IsCompAssign,
                                 bool AllowBothBool,
                                 bool AllowBoolConversions,
                                 bool AllowBoolOperation,
                                 bool ReportInvalid) {
if (!IsCompAssign) {
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}
RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
  return QualType();

// For conversion purposes, we ignore any qualifiers.
// For example, "const float" and "float" are equivalent.
QualType LHSType = LHS.get()->getType().getUnqualifiedType();
QualType RHSType = RHS.get()->getType().getUnqualifiedType();

const VectorType *LHSVecType = LHSType->getAs<VectorType>();
const VectorType *RHSVecType = RHSType->getAs<VectorType>();
assert(LHSVecType || RHSVecType)(static_cast <bool> (LHSVecType || RHSVecType) ? void (
0) : __assert_fail ("LHSVecType || RHSVecType", "clang/lib/Sema/SemaExpr.cpp"
, 10785, __extension__ __PRETTY_FUNCTION__));

if ((LHSVecType && LHSVecType->getElementType()->isBFloat16Type()) ||
    (RHSVecType && RHSVecType->getElementType()->isBFloat16Type()))
  return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();

// AltiVec-style "vector bool op vector bool" combinations are allowed
// for some operators but not others.
if (!AllowBothBool &&
    LHSVecType && LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
    RHSVecType && RHSVecType->getVectorKind() == VectorType::AltiVecBool)
  return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();

// This operation may not be performed on boolean vectors.
if (!AllowBoolOperation &&
    (LHSType->isExtVectorBoolType() || RHSType->isExtVectorBoolType()))
  return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();

// If the vector types are identical, return.
if (Context.hasSameType(LHSType, RHSType))
  return Context.getCommonSugaredType(LHSType, RHSType);

// If we have compatible AltiVec and GCC vector types, use the AltiVec type.
if (LHSVecType && RHSVecType &&
    Context.areCompatibleVectorTypes(LHSType, RHSType)) {
  if (isa<ExtVectorType>(LHSVecType)) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
    return LHSType;
  }

  if (!IsCompAssign)
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
  return RHSType;
}

// AllowBoolConversions says that bool and non-bool AltiVec vectors
// can be mixed, with the result being the non-bool type.  The non-bool
// operand must have integer element type.
if (AllowBoolConversions && LHSVecType && RHSVecType &&
    LHSVecType->getNumElements() == RHSVecType->getNumElements() &&
    (Context.getTypeSize(LHSVecType->getElementType()) ==
     Context.getTypeSize(RHSVecType->getElementType()))) {
  if (LHSVecType->getVectorKind() == VectorType::AltiVecVector &&
      LHSVecType->getElementType()->isIntegerType() &&
      RHSVecType->getVectorKind() == VectorType::AltiVecBool) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
    return LHSType;
  }
  if (!IsCompAssign &&
      LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
      RHSVecType->getVectorKind() == VectorType::AltiVecVector &&
      RHSVecType->getElementType()->isIntegerType()) {
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
    return RHSType;
  }
}

// Expressions containing fixed-length and sizeless SVE/RVV vectors are
// invalid since the ambiguity can affect the ABI.
auto IsSveRVVConversion = [](QualType FirstType, QualType SecondType,
                             unsigned &SVEorRVV) {
  const VectorType *VecType = SecondType->getAs<VectorType>();
  SVEorRVV = 0;
  if (FirstType->isSizelessBuiltinType() && VecType) {
    if (VecType->getVectorKind() == VectorType::SveFixedLengthDataVector ||
        VecType->getVectorKind() == VectorType::SveFixedLengthPredicateVector)
      return true;
    if (VecType->getVectorKind() == VectorType::RVVFixedLengthDataVector) {
      SVEorRVV = 1;
      return true;
    }
  }

  return false;
};

unsigned SVEorRVV;
if (IsSveRVVConversion(LHSType, RHSType, SVEorRVV) ||
    IsSveRVVConversion(RHSType, LHSType, SVEorRVV)) {
  Diag(Loc, diag::err_typecheck_sve_rvv_ambiguous)
      << SVEorRVV << LHSType << RHSType;
  return QualType();
}

// Expressions containing GNU and SVE or RVV (fixed or sizeless) vectors are
// invalid since the ambiguity can affect the ABI.
auto IsSveRVVGnuConversion = [](QualType FirstType, QualType SecondType,
                                unsigned &SVEorRVV) {
  const VectorType *FirstVecType = FirstType->getAs<VectorType>();
  const VectorType *SecondVecType = SecondType->getAs<VectorType>();

  SVEorRVV = 0;
  if (FirstVecType && SecondVecType) {
    if (FirstVecType->getVectorKind() == VectorType::GenericVector) {
      if (SecondVecType->getVectorKind() ==
              VectorType::SveFixedLengthDataVector ||
          SecondVecType->getVectorKind() ==
              VectorType::SveFixedLengthPredicateVector)
        return true;
      if (SecondVecType->getVectorKind() ==
          VectorType::RVVFixedLengthDataVector) {
        SVEorRVV = 1;
        return true;
      }
    }
    return false;
  }

  if (SecondVecType &&
      SecondVecType->getVectorKind() == VectorType::GenericVector) {
    if (FirstType->isSVESizelessBuiltinType())
      return true;
    if (FirstType->isRVVSizelessBuiltinType()) {
      SVEorRVV = 1;
      return true;
    }
  }

  return false;
};

if (IsSveRVVGnuConversion(LHSType, RHSType, SVEorRVV) ||
    IsSveRVVGnuConversion(RHSType, LHSType, SVEorRVV)) {
  Diag(Loc, diag::err_typecheck_sve_rvv_gnu_ambiguous)
      << SVEorRVV << LHSType << RHSType;
  return QualType();
}

// If there's a vector type and a scalar, try to convert the scalar to
// the vector element type and splat.
unsigned DiagID = diag::err_typecheck_vector_not_convertable;
if (!RHSVecType) {
  if (isa<ExtVectorType>(LHSVecType)) {
    if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
                                  LHSVecType->getElementType(), LHSType,
                                  DiagID))
      return LHSType;
  } else {
    if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
      return LHSType;
  }
}
if (!LHSVecType) {
  if (isa<ExtVectorType>(RHSVecType)) {
    if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
                                  LHSType, RHSVecType->getElementType(),
                                  RHSType, DiagID))
      return RHSType;
  } else {
    if (LHS.get()->isLValue() ||
        !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
      return RHSType;
  }
}

// FIXME: The code below also handles conversion between vectors and
// non-scalars, we should break this down into fine grained specific checks
// and emit proper diagnostics.
QualType VecType = LHSVecType ? LHSType : RHSType;
const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
QualType OtherType = LHSVecType ? RHSType : LHSType;
ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
if (isLaxVectorConversion(OtherType, VecType)) {
  if (Context.getTargetInfo().getTriple().isPPC() &&
      anyAltivecTypes(RHSType, LHSType) &&
      !Context.areCompatibleVectorTypes(RHSType, LHSType))
    Diag(Loc, diag::warn_deprecated_lax_vec_conv_all) << RHSType << LHSType;
  // If we're allowing lax vector conversions, only the total (data) size
  // needs to be the same. For non compound assignment, if one of the types is
  // scalar, the result is always the vector type.
  if (!IsCompAssign) {
    *OtherExpr = ImpCastExprToType(OtherExpr->get(), VecType, CK_BitCast);
    return VecType;
  // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
  // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
  // type. Note that this is already done by non-compound assignments in
  // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
  // <1 x T> -> T. The result is also a vector type.
  } else if (OtherType->isExtVectorType() || OtherType->isVectorType() ||
             (OtherType->isScalarType() && VT->getNumElements() == 1)) {
    ExprResult *RHSExpr = &RHS;
    *RHSExpr = ImpCastExprToType(RHSExpr->get(), LHSType, CK_BitCast);
    return VecType;
  }
}

// Okay, the expression is invalid.

// If there's a non-vector, non-real operand, diagnose that.
if ((!RHSVecType && !RHSType->isRealType()) ||
    (!LHSVecType && !LHSType->isRealType())) {
  Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
    << LHSType << RHSType
    << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
  return QualType();
}

// OpenCL V1.1 6.2.6.p1:
// If the operands are of more than one vector type, then an error shall
// occur. Implicit conversions between vector types are not permitted, per
// section 6.2.1.
if (getLangOpts().OpenCL &&
    RHSVecType && isa<ExtVectorType>(RHSVecType) &&
    LHSVecType && isa<ExtVectorType>(LHSVecType)) {
  Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
                                                         << RHSType;
  return QualType();
}


// If there is a vector type that is not a ExtVector and a scalar, we reach
// this point if scalar could not be converted to the vector's element type
// without truncation.
if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
    (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
  QualType Scalar = LHSVecType ? RHSType : LHSType;
  QualType Vector = LHSVecType ? LHSType : RHSType;
  unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
  Diag(Loc,
       diag::err_typecheck_vector_not_convertable_implict_truncation)
      << ScalarOrVector << Scalar << Vector;

  return QualType();
}

// Otherwise, use the generic diagnostic.
Diag(Loc, DiagID)
  << LHSType << RHSType
  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
11015}

11017QualType Sema::CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                         SourceLocation Loc,
                                         bool IsCompAssign,
                                         ArithConvKind OperationKind) {
if (!IsCompAssign) {
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}
RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
  return QualType();

QualType LHSType = LHS.get()->getType().getUnqualifiedType();
QualType RHSType = RHS.get()->getType().getUnqualifiedType();

const BuiltinType *LHSBuiltinTy = LHSType->getAs<BuiltinType>();
const BuiltinType *RHSBuiltinTy = RHSType->getAs<BuiltinType>();

unsigned DiagID = diag::err_typecheck_invalid_operands;
if ((OperationKind == ACK_Arithmetic) &&
    ((LHSBuiltinTy && LHSBuiltinTy->isSVEBool()) ||
     (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
  Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                    << RHS.get()->getSourceRange();
  return QualType();
}

if (Context.hasSameType(LHSType, RHSType))
  return LHSType;

if (LHSType->isVLSTBuiltinType() && !RHSType->isVLSTBuiltinType()) {
  if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
    return LHSType;
}
if (RHSType->isVLSTBuiltinType() && !LHSType->isVLSTBuiltinType()) {
  if (LHS.get()->isLValue() ||
      !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
    return RHSType;
}

if ((!LHSType->isVLSTBuiltinType() && !LHSType->isRealType()) ||
    (!RHSType->isVLSTBuiltinType() && !RHSType->isRealType())) {
  Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
      << LHSType << RHSType << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();
  return QualType();
}

if (LHSType->isVLSTBuiltinType() && RHSType->isVLSTBuiltinType() &&
    Context.getBuiltinVectorTypeInfo(LHSBuiltinTy).EC !=
        Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC) {
  Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
      << LHSType << RHSType << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();
  return QualType();
}

if (LHSType->isVLSTBuiltinType() || RHSType->isVLSTBuiltinType()) {
  QualType Scalar = LHSType->isVLSTBuiltinType() ? RHSType : LHSType;
  QualType Vector = LHSType->isVLSTBuiltinType() ? LHSType : RHSType;
  bool ScalarOrVector =
      LHSType->isVLSTBuiltinType() && RHSType->isVLSTBuiltinType();

  Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
      << ScalarOrVector << Scalar << Vector;

  return QualType();
}

Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                  << RHS.get()->getSourceRange();
return QualType();
11090}

11092// checkArithmeticNull - Detect when a NULL constant is used improperly in an
11093// expression.  These are mainly cases where the null pointer is used as an
11094// integer instead of a pointer.
11095static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS,
                              SourceLocation Loc, bool IsCompare) {
// The canonical way to check for a GNU null is with isNullPointerConstant,
// but we use a bit of a hack here for speed; this is a relatively
// hot path, and isNullPointerConstant is slow.
bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts());
bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts());

QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType();

// Avoid analyzing cases where the result will either be invalid (and
// diagnosed as such) or entirely valid and not something to warn about.
if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() ||
    NonNullType->isMemberPointerType() || NonNullType->isFunctionType())
  return;

// Comparison operations would not make sense with a null pointer no matter
// what the other expression is.
if (!IsCompare) {
  S.Diag(Loc, diag::warn_null_in_arithmetic_operation)
      << (LHSNull ? LHS.get()->getSourceRange() : SourceRange())
      << (RHSNull ? RHS.get()->getSourceRange() : SourceRange());
  return;
}

// The rest of the operations only make sense with a null pointer
// if the other expression is a pointer.
if (LHSNull == RHSNull || NonNullType->isAnyPointerType() ||
    NonNullType->canDecayToPointerType())
  return;

S.Diag(Loc, diag::warn_null_in_comparison_operation)
    << LHSNull /* LHS is NULL */ << NonNullType
    << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
11129}

11131static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
                                        SourceLocation Loc) {
const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
if (!LUE || !RUE)
  return;
if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
    RUE->getKind() != UETT_SizeOf)
  return;

const Expr *LHSArg = LUE->getArgumentExpr()->IgnoreParens();
QualType LHSTy = LHSArg->getType();
QualType RHSTy;

if (RUE->isArgumentType())
  RHSTy = RUE->getArgumentType().getNonReferenceType();
else
  RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();

if (LHSTy->isPointerType() && !RHSTy->isPointerType()) {
  if (!S.Context.hasSameUnqualifiedType(LHSTy->getPointeeType(), RHSTy))
    return;

  S.Diag(Loc, diag::warn_division_sizeof_ptr) << LHS << LHS->getSourceRange();
  if (const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
    if (const ValueDecl *LHSArgDecl = DRE->getDecl())
      S.Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here)
          << LHSArgDecl;
  }
} else if (const auto *ArrayTy = S.Context.getAsArrayType(LHSTy)) {
  QualType ArrayElemTy = ArrayTy->getElementType();
  if (ArrayElemTy != S.Context.getBaseElementType(ArrayTy) ||
      ArrayElemTy->isDependentType() || RHSTy->isDependentType() ||
      RHSTy->isReferenceType() || ArrayElemTy->isCharType() ||
      S.Context.getTypeSize(ArrayElemTy) == S.Context.getTypeSize(RHSTy))
    return;
  S.Diag(Loc, diag::warn_division_sizeof_array)
      << LHSArg->getSourceRange() << ArrayElemTy << RHSTy;
  if (const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {
    if (const ValueDecl *LHSArgDecl = DRE->getDecl())
      S.Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here)
          << LHSArgDecl;
  }

  S.Diag(Loc, diag::note_precedence_silence) << RHS;
}
11177}

11179static void DiagnoseBadDivideOrRemainderValues(Sema& S, ExprResult &LHS,
                                             ExprResult &RHS,
                                             SourceLocation Loc, bool IsDiv) {
// Check for division/remainder by zero.
Expr::EvalResult RHSValue;
if (!RHS.get()->isValueDependent() &&
    RHS.get()->EvaluateAsInt(RHSValue, S.Context) &&
    RHSValue.Val.getInt() == 0)
  S.DiagRuntimeBehavior(Loc, RHS.get(),
                        S.PDiag(diag::warn_remainder_division_by_zero)
                          << IsDiv << RHS.get()->getSourceRange());
11190}

11192QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
                                         SourceLocation Loc,
                                         bool IsCompAssign, bool IsDiv) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);

QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();
if (LHSTy->isVectorType() || RHSTy->isVectorType())
  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                             /*AllowBothBool*/ getLangOpts().AltiVec,
                             /*AllowBoolConversions*/ false,
                             /*AllowBooleanOperation*/ false,
                             /*ReportInvalid*/ true);
if (LHSTy->isVLSTBuiltinType() || RHSTy->isVLSTBuiltinType())
  return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                     ACK_Arithmetic);
if (!IsDiv &&
    (LHSTy->isConstantMatrixType() || RHSTy->isConstantMatrixType()))
  return CheckMatrixMultiplyOperands(LHS, RHS, Loc, IsCompAssign);
// For division, only matrix-by-scalar is supported. Other combinations with
// matrix types are invalid.
if (IsDiv && LHSTy->isConstantMatrixType() && RHSTy->isArithmeticType())
  return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);

QualType compType = UsualArithmeticConversions(
    LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();


if (compType.isNull() || !compType->isArithmeticType())
  return InvalidOperands(Loc, LHS, RHS);
if (IsDiv) {
  DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, IsDiv);
  DiagnoseDivisionSizeofPointerOrArray(*this, LHS.get(), RHS.get(), Loc);
}
return compType;
11229}

11231QualType Sema::CheckRemainderOperands(
ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);

if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType()) {
  if (LHS.get()->getType()->hasIntegerRepresentation() &&
      RHS.get()->getType()->hasIntegerRepresentation())
    return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                               /*AllowBothBool*/ getLangOpts().AltiVec,
                               /*AllowBoolConversions*/ false,
                               /*AllowBooleanOperation*/ false,
                               /*ReportInvalid*/ true);
  return InvalidOperands(Loc, LHS, RHS);
}

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType()) {
  if (LHS.get()->getType()->hasIntegerRepresentation() &&
      RHS.get()->getType()->hasIntegerRepresentation())
    return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                       ACK_Arithmetic);

  return InvalidOperands(Loc, LHS, RHS);
}

QualType compType = UsualArithmeticConversions(
    LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();

if (compType.isNull() || !compType->isIntegerType())
  return InvalidOperands(Loc, LHS, RHS);
DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, false /* IsDiv */);
return compType;
11266}

11268/// Diagnose invalid arithmetic on two void pointers.
11269static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc,
                                              Expr *LHSExpr, Expr *RHSExpr) {
S.Diag(Loc, S.getLangOpts().CPlusPlus
              ? diag::err_typecheck_pointer_arith_void_type
              : diag::ext_gnu_void_ptr)
  << 1 /* two pointers */ << LHSExpr->getSourceRange()
                          << RHSExpr->getSourceRange();
11276}

11278/// Diagnose invalid arithmetic on a void pointer.
11279static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc,
                                          Expr *Pointer) {
S.Diag(Loc, S.getLangOpts().CPlusPlus
              ? diag::err_typecheck_pointer_arith_void_type
              : diag::ext_gnu_void_ptr)
  << 0 /* one pointer */ << Pointer->getSourceRange();
11285}

11287/// Diagnose invalid arithmetic on a null pointer.
11288///
11289/// If \p IsGNUIdiom is true, the operation is using the 'p = (i8*)nullptr + n'
11290/// idiom, which we recognize as a GNU extension.
11291///
11292static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc,
                                          Expr *Pointer, bool IsGNUIdiom) {
if (IsGNUIdiom)
  S.Diag(Loc, diag::warn_gnu_null_ptr_arith)
    << Pointer->getSourceRange();
else
  S.Diag(Loc, diag::warn_pointer_arith_null_ptr)
    << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
11300}

11302/// Diagnose invalid subraction on a null pointer.
11303///
11304static void diagnoseSubtractionOnNullPointer(Sema &S, SourceLocation Loc,
                                           Expr *Pointer, bool BothNull) {
// Null - null is valid in C++ [expr.add]p7
if (BothNull && S.getLangOpts().CPlusPlus)
  return;

// Is this s a macro from a system header?
if (S.Diags.getSuppressSystemWarnings() && S.SourceMgr.isInSystemMacro(Loc))
  return;

S.DiagRuntimeBehavior(Loc, Pointer,
                      S.PDiag(diag::warn_pointer_sub_null_ptr)
                          << S.getLangOpts().CPlusPlus
                          << Pointer->getSourceRange());
11318}

11320/// Diagnose invalid arithmetic on two function pointers.
11321static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc,
                                                  Expr *LHS, Expr *RHS) {
assert(LHS->getType()->isAnyPointerType())(static_cast <bool> (LHS->getType()->isAnyPointerType
()) ? void (0) : __assert_fail ("LHS->getType()->isAnyPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 11323, __extension__ __PRETTY_FUNCTION__
));
assert(RHS->getType()->isAnyPointerType())(static_cast <bool> (RHS->getType()->isAnyPointerType
()) ? void (0) : __assert_fail ("RHS->getType()->isAnyPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 11324, __extension__ __PRETTY_FUNCTION__
));
S.Diag(Loc, S.getLangOpts().CPlusPlus
              ? diag::err_typecheck_pointer_arith_function_type
              : diag::ext_gnu_ptr_func_arith)
  << 1 /* two pointers */ << LHS->getType()->getPointeeType()
  // We only show the second type if it differs from the first.
  << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
                                                 RHS->getType())
  << RHS->getType()->getPointeeType()
  << LHS->getSourceRange() << RHS->getSourceRange();
11334}

11336/// Diagnose invalid arithmetic on a function pointer.
11337static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc,
                                              Expr *Pointer) {
assert(Pointer->getType()->isAnyPointerType())(static_cast <bool> (Pointer->getType()->isAnyPointerType
()) ? void (0) : __assert_fail ("Pointer->getType()->isAnyPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 11339, __extension__ __PRETTY_FUNCTION__
));
S.Diag(Loc, S.getLangOpts().CPlusPlus
              ? diag::err_typecheck_pointer_arith_function_type
              : diag::ext_gnu_ptr_func_arith)
  << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
  << 0 /* one pointer, so only one type */
  << Pointer->getSourceRange();
11346}

11348/// Emit error if Operand is incomplete pointer type
11349///
11350/// \returns True if pointer has incomplete type
11351static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc,
                                               Expr *Operand) {
QualType ResType = Operand->getType();
if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
  ResType = ResAtomicType->getValueType();

assert(ResType->isAnyPointerType() && !ResType->isDependentType())(static_cast <bool> (ResType->isAnyPointerType() &&
 !ResType->isDependentType()) ? void (0) : __assert_fail (
"ResType->isAnyPointerType() && !ResType->isDependentType()"
, "clang/lib/Sema/SemaExpr.cpp", 11357, __extension__ __PRETTY_FUNCTION__
));
QualType PointeeTy = ResType->getPointeeType();
return S.RequireCompleteSizedType(
    Loc, PointeeTy,
    diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
    Operand->getSourceRange());
11363}

11365/// Check the validity of an arithmetic pointer operand.
11366///
11367/// If the operand has pointer type, this code will check for pointer types
11368/// which are invalid in arithmetic operations. These will be diagnosed
11369/// appropriately, including whether or not the use is supported as an
11370/// extension.
11371///
11372/// \returns True when the operand is valid to use (even if as an extension).
11373static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
                                          Expr *Operand) {
QualType ResType = Operand->getType();
if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
  ResType = ResAtomicType->getValueType();

if (!ResType->isAnyPointerType()) return true;

QualType PointeeTy = ResType->getPointeeType();
if (PointeeTy->isVoidType()) {
  diagnoseArithmeticOnVoidPointer(S, Loc, Operand);
  return !S.getLangOpts().CPlusPlus;
}
if (PointeeTy->isFunctionType()) {
  diagnoseArithmeticOnFunctionPointer(S, Loc, Operand);
  return !S.getLangOpts().CPlusPlus;
}

if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false;

return true;
11394}

11396/// Check the validity of a binary arithmetic operation w.r.t. pointer
11397/// operands.
11398///
11399/// This routine will diagnose any invalid arithmetic on pointer operands much
11400/// like \see checkArithmeticOpPointerOperand. However, it has special logic
11401/// for emitting a single diagnostic even for operations where both LHS and RHS
11402/// are (potentially problematic) pointers.
11403///
11404/// \returns True when the operand is valid to use (even if as an extension).
11405static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
                                              Expr *LHSExpr, Expr *RHSExpr) {
bool isLHSPointer = LHSExpr->getType()->isAnyPointerType();
bool isRHSPointer = RHSExpr->getType()->isAnyPointerType();
if (!isLHSPointer && !isRHSPointer) return true;

QualType LHSPointeeTy, RHSPointeeTy;
if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();

// if both are pointers check if operation is valid wrt address spaces
if (isLHSPointer && isRHSPointer) {
  if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
    S.Diag(Loc,
           diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
        << LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
        << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
    return false;
  }
}

// Check for arithmetic on pointers to incomplete types.
bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType();
bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType();
if (isLHSVoidPtr || isRHSVoidPtr) {
  if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
  else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
  else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);

  return !S.getLangOpts().CPlusPlus;
}

bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType();
bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType();
if (isLHSFuncPtr || isRHSFuncPtr) {
  if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
  else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
                                                              RHSExpr);
  else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);

  return !S.getLangOpts().CPlusPlus;
}

if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr))
  return false;
if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr))
  return false;

return true;
11454}

11456/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
11457/// literal.
11458static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
                                Expr *LHSExpr, Expr *RHSExpr) {
StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
Expr* IndexExpr = RHSExpr;
if (!StrExpr) {
  StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts());
  IndexExpr = LHSExpr;
}

bool IsStringPlusInt = StrExpr &&
    IndexExpr->getType()->isIntegralOrUnscopedEnumerationType();
if (!IsStringPlusInt || IndexExpr->isValueDependent())
  return;

SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
Self.Diag(OpLoc, diag::warn_string_plus_int)
    << DiagRange << IndexExpr->IgnoreImpCasts()->getType();

// Only print a fixit for "str" + int, not for int + "str".
if (IndexExpr == RHSExpr) {
  SourceLocation EndLoc = Self.getLocForEndOfToken(RHSExpr->getEndLoc());
  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
      << FixItHint::CreateInsertion(LHSExpr->getBeginLoc(), "&")
      << FixItHint::CreateReplacement(SourceRange(OpLoc), "[")
      << FixItHint::CreateInsertion(EndLoc, "]");
} else
  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
11485}

11487/// Emit a warning when adding a char literal to a string.
11488static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
                                 Expr *LHSExpr, Expr *RHSExpr) {
const Expr *StringRefExpr = LHSExpr;
const CharacterLiteral *CharExpr =
    dyn_cast<CharacterLiteral>(RHSExpr->IgnoreImpCasts());

if (!CharExpr) {
  CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->IgnoreImpCasts());
  StringRefExpr = RHSExpr;
}

if (!CharExpr || !StringRefExpr)
  return;

const QualType StringType = StringRefExpr->getType();

// Return if not a PointerType.
if (!StringType->isAnyPointerType())
  return;

// Return if not a CharacterType.
if (!StringType->getPointeeType()->isAnyCharacterType())
  return;

ASTContext &Ctx = Self.getASTContext();
SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());

const QualType CharType = CharExpr->getType();
if (!CharType->isAnyCharacterType() &&
    CharType->isIntegerType() &&
    llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
  Self.Diag(OpLoc, diag::warn_string_plus_char)
      << DiagRange << Ctx.CharTy;
} else {
  Self.Diag(OpLoc, diag::warn_string_plus_char)
      << DiagRange << CharExpr->getType();
}

// Only print a fixit for str + char, not for char + str.
if (isa<CharacterLiteral>(RHSExpr->IgnoreImpCasts())) {
  SourceLocation EndLoc = Self.getLocForEndOfToken(RHSExpr->getEndLoc());
  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
      << FixItHint::CreateInsertion(LHSExpr->getBeginLoc(), "&")
      << FixItHint::CreateReplacement(SourceRange(OpLoc), "[")
      << FixItHint::CreateInsertion(EndLoc, "]");
} else {
  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
}
11536}

11538/// Emit error when two pointers are incompatible.
11539static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc,
                                         Expr *LHSExpr, Expr *RHSExpr) {
assert(LHSExpr->getType()->isAnyPointerType())(static_cast <bool> (LHSExpr->getType()->isAnyPointerType
()) ? void (0) : __assert_fail ("LHSExpr->getType()->isAnyPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 11541, __extension__ __PRETTY_FUNCTION__
));
assert(RHSExpr->getType()->isAnyPointerType())(static_cast <bool> (RHSExpr->getType()->isAnyPointerType
()) ? void (0) : __assert_fail ("RHSExpr->getType()->isAnyPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 11542, __extension__ __PRETTY_FUNCTION__
));
S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
  << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
  << RHSExpr->getSourceRange();
11546}

11548// C99 6.5.6
11549QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
                                   SourceLocation Loc, BinaryOperatorKind Opc,
                                   QualType* CompLHSTy) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);

if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType()) {
  QualType compType =
      CheckVectorOperands(LHS, RHS, Loc, CompLHSTy,
                          /*AllowBothBool*/ getLangOpts().AltiVec,
                          /*AllowBoolConversions*/ getLangOpts().ZVector,
                          /*AllowBooleanOperation*/ false,
                          /*ReportInvalid*/ true);
  if (CompLHSTy) *CompLHSTy = compType;
  return compType;
}

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType()) {
  QualType compType =
      CheckSizelessVectorOperands(LHS, RHS, Loc, CompLHSTy, ACK_Arithmetic);
  if (CompLHSTy)
    *CompLHSTy = compType;
  return compType;
}

if (LHS.get()->getType()->isConstantMatrixType() ||
    RHS.get()->getType()->isConstantMatrixType()) {
  QualType compType =
      CheckMatrixElementwiseOperands(LHS, RHS, Loc, CompLHSTy);
  if (CompLHSTy)
    *CompLHSTy = compType;
  return compType;
}

QualType compType = UsualArithmeticConversions(
    LHS, RHS, Loc, CompLHSTy ? ACK_CompAssign : ACK_Arithmetic);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();

// Diagnose "string literal" '+' int and string '+' "char literal".
if (Opc == BO_Add) {
  diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get());
  diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get());
}

// handle the common case first (both operands are arithmetic).
if (!compType.isNull() && compType->isArithmeticType()) {
  if (CompLHSTy) *CompLHSTy = compType;
  return compType;
}

// Type-checking.  Ultimately the pointer's going to be in PExp;
// note that we bias towards the LHS being the pointer.
Expr *PExp = LHS.get(), *IExp = RHS.get();

bool isObjCPointer;
if (PExp->getType()->isPointerType()) {
  isObjCPointer = false;
} else if (PExp->getType()->isObjCObjectPointerType()) {
  isObjCPointer = true;
} else {
  std::swap(PExp, IExp);
  if (PExp->getType()->isPointerType()) {
    isObjCPointer = false;
  } else if (PExp->getType()->isObjCObjectPointerType()) {
    isObjCPointer = true;
  } else {
    return InvalidOperands(Loc, LHS, RHS);
  }
}
assert(PExp->getType()->isAnyPointerType())(static_cast <bool> (PExp->getType()->isAnyPointerType
()) ? void (0) : __assert_fail ("PExp->getType()->isAnyPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 11620, __extension__ __PRETTY_FUNCTION__
));

if (!IExp->getType()->isIntegerType())
  return InvalidOperands(Loc, LHS, RHS);

// Adding to a null pointer results in undefined behavior.
if (PExp->IgnoreParenCasts()->isNullPointerConstant(
        Context, Expr::NPC_ValueDependentIsNotNull)) {
  // In C++ adding zero to a null pointer is defined.
  Expr::EvalResult KnownVal;
  if (!getLangOpts().CPlusPlus ||
      (!IExp->isValueDependent() &&
       (!IExp->EvaluateAsInt(KnownVal, Context) ||
        KnownVal.Val.getInt() != 0))) {
    // Check the conditions to see if this is the 'p = nullptr + n' idiom.
    bool IsGNUIdiom = BinaryOperator::isNullPointerArithmeticExtension(
        Context, BO_Add, PExp, IExp);
    diagnoseArithmeticOnNullPointer(*this, Loc, PExp, IsGNUIdiom);
  }
}

if (!checkArithmeticOpPointerOperand(*this, Loc, PExp))
  return QualType();

if (isObjCPointer && checkArithmeticOnObjCPointer(*this, Loc, PExp))
  return QualType();

// Check array bounds for pointer arithemtic
CheckArrayAccess(PExp, IExp);

if (CompLHSTy) {
  QualType LHSTy = Context.isPromotableBitField(LHS.get());
  if (LHSTy.isNull()) {
    LHSTy = LHS.get()->getType();
    if (Context.isPromotableIntegerType(LHSTy))
      LHSTy = Context.getPromotedIntegerType(LHSTy);
  }
  *CompLHSTy = LHSTy;
}

return PExp->getType();
11661}

11663// C99 6.5.6
11664QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
                                      SourceLocation Loc,
                                      QualType* CompLHSTy) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);

if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType()) {
  QualType compType =
      CheckVectorOperands(LHS, RHS, Loc, CompLHSTy,
                          /*AllowBothBool*/ getLangOpts().AltiVec,
                          /*AllowBoolConversions*/ getLangOpts().ZVector,
                          /*AllowBooleanOperation*/ false,
                          /*ReportInvalid*/ true);
  if (CompLHSTy) *CompLHSTy = compType;
  return compType;
}

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType()) {
  QualType compType =
      CheckSizelessVectorOperands(LHS, RHS, Loc, CompLHSTy, ACK_Arithmetic);
  if (CompLHSTy)
    *CompLHSTy = compType;
  return compType;
}

if (LHS.get()->getType()->isConstantMatrixType() ||
    RHS.get()->getType()->isConstantMatrixType()) {
  QualType compType =
      CheckMatrixElementwiseOperands(LHS, RHS, Loc, CompLHSTy);
  if (CompLHSTy)
    *CompLHSTy = compType;
  return compType;
}

QualType compType = UsualArithmeticConversions(
    LHS, RHS, Loc, CompLHSTy ? ACK_CompAssign : ACK_Arithmetic);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();

// Enforce type constraints: C99 6.5.6p3.

// Handle the common case first (both operands are arithmetic).
if (!compType.isNull() && compType->isArithmeticType()) {
  if (CompLHSTy) *CompLHSTy = compType;
  return compType;
}

// Either ptr - int   or   ptr - ptr.
if (LHS.get()->getType()->isAnyPointerType()) {
  QualType lpointee = LHS.get()->getType()->getPointeeType();

  // Diagnose bad cases where we step over interface counts.
  if (LHS.get()->getType()->isObjCObjectPointerType() &&
      checkArithmeticOnObjCPointer(*this, Loc, LHS.get()))
    return QualType();

  // The result type of a pointer-int computation is the pointer type.
  if (RHS.get()->getType()->isIntegerType()) {
    // Subtracting from a null pointer should produce a warning.
    // The last argument to the diagnose call says this doesn't match the
    // GNU int-to-pointer idiom.
    if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(Context,
                                         Expr::NPC_ValueDependentIsNotNull)) {
      // In C++ adding zero to a null pointer is defined.
      Expr::EvalResult KnownVal;
      if (!getLangOpts().CPlusPlus ||
          (!RHS.get()->isValueDependent() &&
           (!RHS.get()->EvaluateAsInt(KnownVal, Context) ||
            KnownVal.Val.getInt() != 0))) {
        diagnoseArithmeticOnNullPointer(*this, Loc, LHS.get(), false);
      }
    }

    if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get()))
      return QualType();

    // Check array bounds for pointer arithemtic
    CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr,
                     /*AllowOnePastEnd*/true, /*IndexNegated*/true);

    if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
    return LHS.get()->getType();
  }

  // Handle pointer-pointer subtractions.
  if (const PointerType *RHSPTy
        = RHS.get()->getType()->getAs<PointerType>()) {
    QualType rpointee = RHSPTy->getPointeeType();

    if (getLangOpts().CPlusPlus) {
      // Pointee types must be the same: C++ [expr.add]
      if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
        diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
      }
    } else {
      // Pointee types must be compatible C99 6.5.6p3
      if (!Context.typesAreCompatible(
              Context.getCanonicalType(lpointee).getUnqualifiedType(),
              Context.getCanonicalType(rpointee).getUnqualifiedType())) {
        diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
        return QualType();
      }
    }

    if (!checkArithmeticBinOpPointerOperands(*this, Loc,
                                             LHS.get(), RHS.get()))
      return QualType();

    bool LHSIsNullPtr = LHS.get()->IgnoreParenCasts()->isNullPointerConstant(
        Context, Expr::NPC_ValueDependentIsNotNull);
    bool RHSIsNullPtr = RHS.get()->IgnoreParenCasts()->isNullPointerConstant(
        Context, Expr::NPC_ValueDependentIsNotNull);

    // Subtracting nullptr or from nullptr is suspect
    if (LHSIsNullPtr)
      diagnoseSubtractionOnNullPointer(*this, Loc, LHS.get(), RHSIsNullPtr);
    if (RHSIsNullPtr)
      diagnoseSubtractionOnNullPointer(*this, Loc, RHS.get(), LHSIsNullPtr);

    // The pointee type may have zero size.  As an extension, a structure or
    // union may have zero size or an array may have zero length.  In this
    // case subtraction does not make sense.
    if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
      CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
      if (ElementSize.isZero()) {
        Diag(Loc,diag::warn_sub_ptr_zero_size_types)
          << rpointee.getUnqualifiedType()
          << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
      }
    }

    if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
    return Context.getPointerDiffType();
  }
}

return InvalidOperands(Loc, LHS, RHS);
11802}

11804static bool isScopedEnumerationType(QualType T) {
if (const EnumType *ET = T->getAs<EnumType>())
  return ET->getDecl()->isScoped();
return false;
11808}

11810static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS,
                                 SourceLocation Loc, BinaryOperatorKind Opc,
                                 QualType LHSType) {
// OpenCL 6.3j: shift values are effectively % word size of LHS (more defined),
// so skip remaining warnings as we don't want to modify values within Sema.
if (S.getLangOpts().OpenCL)
  return;

// Check right/shifter operand
Expr::EvalResult RHSResult;
if (RHS.get()->isValueDependent() ||
    !RHS.get()->EvaluateAsInt(RHSResult, S.Context))
  return;
llvm::APSInt Right = RHSResult.Val.getInt();

if (Right.isNegative()) {
  S.DiagRuntimeBehavior(Loc, RHS.get(),
                        S.PDiag(diag::warn_shift_negative)
                          << RHS.get()->getSourceRange());
  return;
}

QualType LHSExprType = LHS.get()->getType();
uint64_t LeftSize = S.Context.getTypeSize(LHSExprType);
if (LHSExprType->isBitIntType())
  LeftSize = S.Context.getIntWidth(LHSExprType);
else if (LHSExprType->isFixedPointType()) {
  auto FXSema = S.Context.getFixedPointSemantics(LHSExprType);
  LeftSize = FXSema.getWidth() - (unsigned)FXSema.hasUnsignedPadding();
}
llvm::APInt LeftBits(Right.getBitWidth(), LeftSize);
if (Right.uge(LeftBits)) {
  S.DiagRuntimeBehavior(Loc, RHS.get(),
                        S.PDiag(diag::warn_shift_gt_typewidth)
                          << RHS.get()->getSourceRange());
  return;
}

// FIXME: We probably need to handle fixed point types specially here.
if (Opc != BO_Shl || LHSExprType->isFixedPointType())
  return;

// When left shifting an ICE which is signed, we can check for overflow which
// according to C++ standards prior to C++2a has undefined behavior
// ([expr.shift] 5.8/2). Unsigned integers have defined behavior modulo one
// more than the maximum value representable in the result type, so never
// warn for those. (FIXME: Unsigned left-shift overflow in a constant
// expression is still probably a bug.)
Expr::EvalResult LHSResult;
if (LHS.get()->isValueDependent() ||
    LHSType->hasUnsignedIntegerRepresentation() ||
    !LHS.get()->EvaluateAsInt(LHSResult, S.Context))
  return;
llvm::APSInt Left = LHSResult.Val.getInt();

// Don't warn if signed overflow is defined, then all the rest of the
// diagnostics will not be triggered because the behavior is defined.
// Also don't warn in C++20 mode (and newer), as signed left shifts
// always wrap and never overflow.
if (S.getLangOpts().isSignedOverflowDefined() || S.getLangOpts().CPlusPlus20)
  return;

// If LHS does not have a non-negative value then, the
// behavior is undefined before C++2a. Warn about it.
if (Left.isNegative()) {
  S.DiagRuntimeBehavior(Loc, LHS.get(),
                        S.PDiag(diag::warn_shift_lhs_negative)
                          << LHS.get()->getSourceRange());
  return;
}

llvm::APInt ResultBits =
    static_cast<llvm::APInt &>(Right) + Left.getSignificantBits();
if (LeftBits.uge(ResultBits))
  return;
llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue());
Result = Result.shl(Right);

// Print the bit representation of the signed integer as an unsigned
// hexadecimal number.
SmallString<40> HexResult;
Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true);

// If we are only missing a sign bit, this is less likely to result in actual
// bugs -- if the result is cast back to an unsigned type, it will have the
// expected value. Thus we place this behind a different warning that can be
// turned off separately if needed.
if (LeftBits == ResultBits - 1) {
  S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
      << HexResult << LHSType
      << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
  return;
}

S.Diag(Loc, diag::warn_shift_result_gt_typewidth)
    << HexResult.str() << Result.getSignificantBits() << LHSType
    << Left.getBitWidth() << LHS.get()->getSourceRange()
    << RHS.get()->getSourceRange();
11908}

11910/// Return the resulting type when a vector is shifted
11911///        by a scalar or vector shift amount.
11912static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
                               SourceLocation Loc, bool IsCompAssign) {
// OpenCL v1.1 s6.3.j says RHS can be a vector only if LHS is a vector.
if ((S.LangOpts.OpenCL || S.LangOpts.ZVector) &&
    !LHS.get()->getType()->isVectorType()) {
  S.Diag(Loc, diag::err_shift_rhs_only_vector)
    << RHS.get()->getType() << LHS.get()->getType()
    << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
  return QualType();
}

if (!IsCompAssign) {
  LHS = S.UsualUnaryConversions(LHS.get());
  if (LHS.isInvalid()) return QualType();
}

RHS = S.UsualUnaryConversions(RHS.get());
if (RHS.isInvalid()) return QualType();

QualType LHSType = LHS.get()->getType();
// Note that LHS might be a scalar because the routine calls not only in
// OpenCL case.
const VectorType *LHSVecTy = LHSType->getAs<VectorType>();
QualType LHSEleType = LHSVecTy ? LHSVecTy->getElementType() : LHSType;

// Note that RHS might not be a vector.
QualType RHSType = RHS.get()->getType();
const VectorType *RHSVecTy = RHSType->getAs<VectorType>();
QualType RHSEleType = RHSVecTy ? RHSVecTy->getElementType() : RHSType;

// Do not allow shifts for boolean vectors.
if ((LHSVecTy && LHSVecTy->isExtVectorBoolType()) ||
    (RHSVecTy && RHSVecTy->isExtVectorBoolType())) {
  S.Diag(Loc, diag::err_typecheck_invalid_operands)
      << LHS.get()->getType() << RHS.get()->getType()
      << LHS.get()->getSourceRange();
  return QualType();
}

// The operands need to be integers.
if (!LHSEleType->isIntegerType()) {
  S.Diag(Loc, diag::err_typecheck_expect_int)
    << LHS.get()->getType() << LHS.get()->getSourceRange();
  return QualType();
}

if (!RHSEleType->isIntegerType()) {
  S.Diag(Loc, diag::err_typecheck_expect_int)
    << RHS.get()->getType() << RHS.get()->getSourceRange();
  return QualType();
}

if (!LHSVecTy) {
  assert(RHSVecTy)(static_cast <bool> (RHSVecTy) ? void (0) : __assert_fail
 ("RHSVecTy", "clang/lib/Sema/SemaExpr.cpp", 11965, __extension__
 __PRETTY_FUNCTION__));
  if (IsCompAssign)
    return RHSType;
  if (LHSEleType != RHSEleType) {
    LHS = S.ImpCastExprToType(LHS.get(),RHSEleType, CK_IntegralCast);
    LHSEleType = RHSEleType;
  }
  QualType VecTy =
      S.Context.getExtVectorType(LHSEleType, RHSVecTy->getNumElements());
  LHS = S.ImpCastExprToType(LHS.get(), VecTy, CK_VectorSplat);
  LHSType = VecTy;
} else if (RHSVecTy) {
  // OpenCL v1.1 s6.3.j says that for vector types, the operators
  // are applied component-wise. So if RHS is a vector, then ensure
  // that the number of elements is the same as LHS...
  if (RHSVecTy->getNumElements() != LHSVecTy->getNumElements()) {
    S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
      << LHS.get()->getType() << RHS.get()->getType()
      << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
    return QualType();
  }
  if (!S.LangOpts.OpenCL && !S.LangOpts.ZVector) {
    const BuiltinType *LHSBT = LHSEleType->getAs<clang::BuiltinType>();
    const BuiltinType *RHSBT = RHSEleType->getAs<clang::BuiltinType>();
    if (LHSBT != RHSBT &&
        S.Context.getTypeSize(LHSBT) != S.Context.getTypeSize(RHSBT)) {
      S.Diag(Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
          << LHS.get()->getType() << RHS.get()->getType()
          << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
    }
  }
} else {
  // ...else expand RHS to match the number of elements in LHS.
  QualType VecTy =
    S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
  RHS = S.ImpCastExprToType(RHS.get(), VecTy, CK_VectorSplat);
}

return LHSType;
12004}

12006static QualType checkSizelessVectorShift(Sema &S, ExprResult &LHS,
                                       ExprResult &RHS, SourceLocation Loc,
                                       bool IsCompAssign) {
if (!IsCompAssign) {
  LHS = S.UsualUnaryConversions(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}

RHS = S.UsualUnaryConversions(RHS.get());
if (RHS.isInvalid())
  return QualType();

QualType LHSType = LHS.get()->getType();
const BuiltinType *LHSBuiltinTy = LHSType->getAs<BuiltinType>();
QualType LHSEleType = LHSType->isVLSTBuiltinType()
                          ? LHSBuiltinTy->getSveEltType(S.getASTContext())
                          : LHSType;

// Note that RHS might not be a vector
QualType RHSType = RHS.get()->getType();
const BuiltinType *RHSBuiltinTy = RHSType->getAs<BuiltinType>();
QualType RHSEleType = RHSType->isVLSTBuiltinType()
                          ? RHSBuiltinTy->getSveEltType(S.getASTContext())
                          : RHSType;

if ((LHSBuiltinTy && LHSBuiltinTy->isSVEBool()) ||
    (RHSBuiltinTy && RHSBuiltinTy->isSVEBool())) {
  S.Diag(Loc, diag::err_typecheck_invalid_operands)
      << LHSType << RHSType << LHS.get()->getSourceRange();
  return QualType();
}

if (!LHSEleType->isIntegerType()) {
  S.Diag(Loc, diag::err_typecheck_expect_int)
      << LHS.get()->getType() << LHS.get()->getSourceRange();
  return QualType();
}

if (!RHSEleType->isIntegerType()) {
  S.Diag(Loc, diag::err_typecheck_expect_int)
      << RHS.get()->getType() << RHS.get()->getSourceRange();
  return QualType();
}

if (LHSType->isVLSTBuiltinType() && RHSType->isVLSTBuiltinType() &&
    (S.Context.getBuiltinVectorTypeInfo(LHSBuiltinTy).EC !=
     S.Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC)) {
  S.Diag(Loc, diag::err_typecheck_invalid_operands)
      << LHSType << RHSType << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();
  return QualType();
}

if (!LHSType->isVLSTBuiltinType()) {
  assert(RHSType->isVLSTBuiltinType())(static_cast <bool> (RHSType->isVLSTBuiltinType()) ?
 void (0) : __assert_fail ("RHSType->isVLSTBuiltinType()",
 "clang/lib/Sema/SemaExpr.cpp", 12061, __extension__ __PRETTY_FUNCTION__
));
  if (IsCompAssign)
    return RHSType;
  if (LHSEleType != RHSEleType) {
    LHS = S.ImpCastExprToType(LHS.get(), RHSEleType, clang::CK_IntegralCast);
    LHSEleType = RHSEleType;
  }
  const llvm::ElementCount VecSize =
      S.Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC;
  QualType VecTy =
      S.Context.getScalableVectorType(LHSEleType, VecSize.getKnownMinValue());
  LHS = S.ImpCastExprToType(LHS.get(), VecTy, clang::CK_VectorSplat);
  LHSType = VecTy;
} else if (RHSBuiltinTy && RHSBuiltinTy->isVLSTBuiltinType()) {
  if (S.Context.getTypeSize(RHSBuiltinTy) !=
      S.Context.getTypeSize(LHSBuiltinTy)) {
    S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
        << LHSType << RHSType << LHS.get()->getSourceRange()
        << RHS.get()->getSourceRange();
    return QualType();
  }
} else {
  const llvm::ElementCount VecSize =
      S.Context.getBuiltinVectorTypeInfo(LHSBuiltinTy).EC;
  if (LHSEleType != RHSEleType) {
    RHS = S.ImpCastExprToType(RHS.get(), LHSEleType, clang::CK_IntegralCast);
    RHSEleType = LHSEleType;
  }
  QualType VecTy =
      S.Context.getScalableVectorType(RHSEleType, VecSize.getKnownMinValue());
  RHS = S.ImpCastExprToType(RHS.get(), VecTy, CK_VectorSplat);
}

return LHSType;
12095}

12097// C99 6.5.7
12098QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS,
                                SourceLocation Loc, BinaryOperatorKind Opc,
                                bool IsCompAssign) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);

// Vector shifts promote their scalar inputs to vector type.
if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType()) {
  if (LangOpts.ZVector) {
    // The shift operators for the z vector extensions work basically
    // like general shifts, except that neither the LHS nor the RHS is
    // allowed to be a "vector bool".
    if (auto LHSVecType = LHS.get()->getType()->getAs<VectorType>())
      if (LHSVecType->getVectorKind() == VectorType::AltiVecBool)
        return InvalidOperands(Loc, LHS, RHS);
    if (auto RHSVecType = RHS.get()->getType()->getAs<VectorType>())
      if (RHSVecType->getVectorKind() == VectorType::AltiVecBool)
        return InvalidOperands(Loc, LHS, RHS);
  }
  return checkVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
}

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType())
  return checkSizelessVectorShift(*this, LHS, RHS, Loc, IsCompAssign);

// Shifts don't perform usual arithmetic conversions, they just do integer
// promotions on each operand. C99 6.5.7p3

// For the LHS, do usual unary conversions, but then reset them away
// if this is a compound assignment.
ExprResult OldLHS = LHS;
LHS = UsualUnaryConversions(LHS.get());
if (LHS.isInvalid())
  return QualType();
QualType LHSType = LHS.get()->getType();
if (IsCompAssign) LHS = OldLHS;

// The RHS is simpler.
RHS = UsualUnaryConversions(RHS.get());
if (RHS.isInvalid())
  return QualType();
QualType RHSType = RHS.get()->getType();

// C99 6.5.7p2: Each of the operands shall have integer type.
// Embedded-C 4.1.6.2.2: The LHS may also be fixed-point.
if ((!LHSType->isFixedPointOrIntegerType() &&
     !LHSType->hasIntegerRepresentation()) ||
    !RHSType->hasIntegerRepresentation())
  return InvalidOperands(Loc, LHS, RHS);

// C++0x: Don't allow scoped enums. FIXME: Use something better than
// hasIntegerRepresentation() above instead of this.
if (isScopedEnumerationType(LHSType) ||
    isScopedEnumerationType(RHSType)) {
  return InvalidOperands(Loc, LHS, RHS);
}
DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType);

// "The type of the result is that of the promoted left operand."
return LHSType;
12159}

12161/// Diagnose bad pointer comparisons.
12162static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc,
                                            ExprResult &LHS, ExprResult &RHS,
                                            bool IsError) {
S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
                    : diag::ext_typecheck_comparison_of_distinct_pointers)
  << LHS.get()->getType() << RHS.get()->getType()
  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
12169}

12171/// Returns false if the pointers are converted to a composite type,
12172/// true otherwise.
12173static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc,
                                         ExprResult &LHS, ExprResult &RHS) {
// C++ [expr.rel]p2:
//   [...] Pointer conversions (4.10) and qualification
//   conversions (4.4) are performed on pointer operands (or on
//   a pointer operand and a null pointer constant) to bring
//   them to their composite pointer type. [...]
//
// C++ [expr.eq]p1 uses the same notion for (in)equality
// comparisons of pointers.

QualType LHSType = LHS.get()->getType();
QualType RHSType = RHS.get()->getType();
assert(LHSType->isPointerType() || RHSType->isPointerType() ||(static_cast <bool> (LHSType->isPointerType() || RHSType
->isPointerType() || LHSType->isMemberPointerType() || RHSType
->isMemberPointerType()) ? void (0) : __assert_fail ("LHSType->isPointerType() || RHSType->isPointerType() || LHSType->isMemberPointerType() || RHSType->isMemberPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 12187, __extension__ __PRETTY_FUNCTION__
))
       LHSType->isMemberPointerType() || RHSType->isMemberPointerType())(static_cast <bool> (LHSType->isPointerType() || RHSType
->isPointerType() || LHSType->isMemberPointerType() || RHSType
->isMemberPointerType()) ? void (0) : __assert_fail ("LHSType->isPointerType() || RHSType->isPointerType() || LHSType->isMemberPointerType() || RHSType->isMemberPointerType()"
, "clang/lib/Sema/SemaExpr.cpp", 12187, __extension__ __PRETTY_FUNCTION__
));

QualType T = S.FindCompositePointerType(Loc, LHS, RHS);
if (T.isNull()) {
  if ((LHSType->isAnyPointerType() || LHSType->isMemberPointerType()) &&
      (RHSType->isAnyPointerType() || RHSType->isMemberPointerType()))
    diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
  else
    S.InvalidOperands(Loc, LHS, RHS);
  return true;
}

return false;
12200}

12202static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc,
                                                  ExprResult &LHS,
                                                  ExprResult &RHS,
                                                  bool IsError) {
S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
                    : diag::ext_typecheck_comparison_of_fptr_to_void)
  << LHS.get()->getType() << RHS.get()->getType()
  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
12210}

12212static bool isObjCObjectLiteral(ExprResult &E) {
switch (E.get()->IgnoreParenImpCasts()->getStmtClass()) {
case Stmt::ObjCArrayLiteralClass:
case Stmt::ObjCDictionaryLiteralClass:
case Stmt::ObjCStringLiteralClass:
case Stmt::ObjCBoxedExprClass:
  return true;
default:
  // Note that ObjCBoolLiteral is NOT an object literal!
  return false;
}
12223}

12225static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
const ObjCObjectPointerType *Type =
  LHS->getType()->getAs<ObjCObjectPointerType>();

// If this is not actually an Objective-C object, bail out.
if (!Type)
  return false;

// Get the LHS object's interface type.
QualType InterfaceType = Type->getPointeeType();

// If the RHS isn't an Objective-C object, bail out.
if (!RHS->getType()->isObjCObjectPointerType())
  return false;

// Try to find the -isEqual: method.
Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector();
ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel,
                                                    InterfaceType,
                                                    /*IsInstance=*/true);
if (!Method) {
  if (Type->isObjCIdType()) {
    // For 'id', just check the global pool.
    Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(),
                                                /*receiverId=*/true);
  } else {
    // Check protocols.
    Method = S.LookupMethodInQualifiedType(IsEqualSel, Type,
                                           /*IsInstance=*/true);
  }
}

if (!Method)
  return false;

QualType T = Method->parameters()[0]->getType();
if (!T->isObjCObjectPointerType())
  return false;

QualType R = Method->getReturnType();
if (!R->isScalarType())
  return false;

return true;
12269}

12271Sema::ObjCLiteralKind Sema::CheckLiteralKind(Expr *FromE) {
FromE = FromE->IgnoreParenImpCasts();
switch (FromE->getStmtClass()) {
  default:
    break;
  case Stmt::ObjCStringLiteralClass:
    // "string literal"
    return LK_String;
  case Stmt::ObjCArrayLiteralClass:
    // "array literal"
    return LK_Array;
  case Stmt::ObjCDictionaryLiteralClass:
    // "dictionary literal"
    return LK_Dictionary;
  case Stmt::BlockExprClass:
    return LK_Block;
  case Stmt::ObjCBoxedExprClass: {
    Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
    switch (Inner->getStmtClass()) {
      case Stmt::IntegerLiteralClass:
      case Stmt::FloatingLiteralClass:
      case Stmt::CharacterLiteralClass:
      case Stmt::ObjCBoolLiteralExprClass:
      case Stmt::CXXBoolLiteralExprClass:
        // "numeric literal"
        return LK_Numeric;
      case Stmt::ImplicitCastExprClass: {
        CastKind CK = cast<CastExpr>(Inner)->getCastKind();
        // Boolean literals can be represented by implicit casts.
        if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
          return LK_Numeric;
        break;
      }
      default:
        break;
    }
    return LK_Boxed;
  }
}
return LK_None;
12311}

12313static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc,
                                        ExprResult &LHS, ExprResult &RHS,
                                        BinaryOperator::Opcode Opc){
Expr *Literal;
Expr *Other;
if (isObjCObjectLiteral(LHS)) {
  Literal = LHS.get();
  Other = RHS.get();
} else {
  Literal = RHS.get();
  Other = LHS.get();
}

// Don't warn on comparisons against nil.
Other = Other->IgnoreParenCasts();
if (Other->isNullPointerConstant(S.getASTContext(),
                                 Expr::NPC_ValueDependentIsNotNull))
  return;

// This should be kept in sync with warn_objc_literal_comparison.
// LK_String should always be after the other literals, since it has its own
// warning flag.
Sema::ObjCLiteralKind LiteralKind = S.CheckLiteralKind(Literal);
assert(LiteralKind != Sema::LK_Block)(static_cast <bool> (LiteralKind != Sema::LK_Block) ? void
 (0) : __assert_fail ("LiteralKind != Sema::LK_Block", "clang/lib/Sema/SemaExpr.cpp"
, 12336, __extension__ __PRETTY_FUNCTION__));
if (LiteralKind == Sema::LK_None) {
  llvm_unreachable("Unknown Objective-C object literal kind")::llvm::llvm_unreachable_internal("Unknown Objective-C object literal kind"
, "clang/lib/Sema/SemaExpr.cpp", 12338);
}

if (LiteralKind == Sema::LK_String)
  S.Diag(Loc, diag::warn_objc_string_literal_comparison)
    << Literal->getSourceRange();
else
  S.Diag(Loc, diag::warn_objc_literal_comparison)
    << LiteralKind << Literal->getSourceRange();

if (BinaryOperator::isEqualityOp(Opc) &&
    hasIsEqualMethod(S, LHS.get(), RHS.get())) {
  SourceLocation Start = LHS.get()->getBeginLoc();
  SourceLocation End = S.getLocForEndOfToken(RHS.get()->getEndLoc());
  CharSourceRange OpRange =
    CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));

  S.Diag(Loc, diag::note_objc_literal_comparison_isequal)
    << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
    << FixItHint::CreateReplacement(OpRange, " isEqual:")
    << FixItHint::CreateInsertion(End, "]");
}
12360}

12362/// Warns on !x < y, !x & y where !(x < y), !(x & y) was probably intended.
12363static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS,
                                         ExprResult &RHS, SourceLocation Loc,
                                         BinaryOperatorKind Opc) {
// Check that left hand side is !something.
UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts());
if (!UO || UO->getOpcode() != UO_LNot) return;

// Only check if the right hand side is non-bool arithmetic type.
if (RHS.get()->isKnownToHaveBooleanValue()) return;

// Make sure that the something in !something is not bool.
Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
if (SubExpr->isKnownToHaveBooleanValue()) return;

// Emit warning.
bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_check)
    << Loc << IsBitwiseOp;

// First note suggest !(x < y)
SourceLocation FirstOpen = SubExpr->getBeginLoc();
SourceLocation FirstClose = RHS.get()->getEndLoc();
FirstClose = S.getLocForEndOfToken(FirstClose);
if (FirstClose.isInvalid())
  FirstOpen = SourceLocation();
S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
    << IsBitwiseOp
    << FixItHint::CreateInsertion(FirstOpen, "(")
    << FixItHint::CreateInsertion(FirstClose, ")");

// Second note suggests (!x) < y
SourceLocation SecondOpen = LHS.get()->getBeginLoc();
SourceLocation SecondClose = LHS.get()->getEndLoc();
SecondClose = S.getLocForEndOfToken(SecondClose);
if (SecondClose.isInvalid())
  SecondOpen = SourceLocation();
S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens)
    << FixItHint::CreateInsertion(SecondOpen, "(")
    << FixItHint::CreateInsertion(SecondClose, ")");
12402}

12404// Returns true if E refers to a non-weak array.
12405static bool checkForArray(const Expr *E) {
const ValueDecl *D = nullptr;
if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E)) {
  D = DR->getDecl();
} else if (const MemberExpr *Mem = dyn_cast<MemberExpr>(E)) {
  if (Mem->isImplicitAccess())
    D = Mem->getMemberDecl();
}
if (!D)
  return false;
return D->getType()->isArrayType() && !D->isWeak();
12416}

12418/// Diagnose some forms of syntactically-obvious tautological comparison.
12419static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
                                         Expr *LHS, Expr *RHS,
                                         BinaryOperatorKind Opc) {
Expr *LHSStripped = LHS->IgnoreParenImpCasts();
Expr *RHSStripped = RHS->IgnoreParenImpCasts();

QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
if (LHSType->hasFloatingRepresentation() ||
    (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)) ||
    S.inTemplateInstantiation())
  return;

// Comparisons between two array types are ill-formed for operator<=>, so
// we shouldn't emit any additional warnings about it.
if (Opc == BO_Cmp && LHSType->isArrayType() && RHSType->isArrayType())
  return;

// For non-floating point types, check for self-comparisons of the form
// x == x, x != x, x < x, etc.  These always evaluate to a constant, and
// often indicate logic errors in the program.
//
// NOTE: Don't warn about comparison expressions resulting from macro
// expansion. Also don't warn about comparisons which are only self
// comparisons within a template instantiation. The warnings should catch
// obvious cases in the definition of the template anyways. The idea is to
// warn when the typed comparison operator will always evaluate to the same
// result.

// Used for indexing into %select in warn_comparison_always
enum {
  AlwaysConstant,
  AlwaysTrue,
  AlwaysFalse,
  AlwaysEqual, // std::strong_ordering::equal from operator<=>
};

// C++2a [depr.array.comp]:
//   Equality and relational comparisons ([expr.eq], [expr.rel]) between two
//   operands of array type are deprecated.
if (S.getLangOpts().CPlusPlus20 && LHSStripped->getType()->isArrayType() &&
    RHSStripped->getType()->isArrayType()) {
  S.Diag(Loc, diag::warn_depr_array_comparison)
      << LHS->getSourceRange() << RHS->getSourceRange()
      << LHSStripped->getType() << RHSStripped->getType();
  // Carry on to produce the tautological comparison warning, if this
  // expression is potentially-evaluated, we can resolve the array to a
  // non-weak declaration, and so on.
}

if (!LHS->getBeginLoc().isMacroID() && !RHS->getBeginLoc().isMacroID()) {
  if (Expr::isSameComparisonOperand(LHS, RHS)) {
    unsigned Result;
    switch (Opc) {
    case BO_EQ:
    case BO_LE:
    case BO_GE:
      Result = AlwaysTrue;
      break;
    case BO_NE:
    case BO_LT:
    case BO_GT:
      Result = AlwaysFalse;
      break;
    case BO_Cmp:
      Result = AlwaysEqual;
      break;
    default:
      Result = AlwaysConstant;
      break;
    }
    S.DiagRuntimeBehavior(Loc, nullptr,
                          S.PDiag(diag::warn_comparison_always)
                              << 0 /*self-comparison*/
                              << Result);
  } else if (checkForArray(LHSStripped) && checkForArray(RHSStripped)) {
    // What is it always going to evaluate to?
    unsigned Result;
    switch (Opc) {
    case BO_EQ: // e.g. array1 == array2
      Result = AlwaysFalse;
      break;
    case BO_NE: // e.g. array1 != array2
      Result = AlwaysTrue;
      break;
    default: // e.g. array1 <= array2
      // The best we can say is 'a constant'
      Result = AlwaysConstant;
      break;
    }
    S.DiagRuntimeBehavior(Loc, nullptr,
                          S.PDiag(diag::warn_comparison_always)
                              << 1 /*array comparison*/
                              << Result);
  }
}

if (isa<CastExpr>(LHSStripped))
  LHSStripped = LHSStripped->IgnoreParenCasts();
if (isa<CastExpr>(RHSStripped))
  RHSStripped = RHSStripped->IgnoreParenCasts();

// Warn about comparisons against a string constant (unless the other
// operand is null); the user probably wants string comparison function.
Expr *LiteralString = nullptr;
Expr *LiteralStringStripped = nullptr;
if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
    !RHSStripped->isNullPointerConstant(S.Context,
                                        Expr::NPC_ValueDependentIsNull)) {
  LiteralString = LHS;
  LiteralStringStripped = LHSStripped;
} else if ((isa<StringLiteral>(RHSStripped) ||
            isa<ObjCEncodeExpr>(RHSStripped)) &&
           !LHSStripped->isNullPointerConstant(S.Context,
                                        Expr::NPC_ValueDependentIsNull)) {
  LiteralString = RHS;
  LiteralStringStripped = RHSStripped;
}

if (LiteralString) {
  S.DiagRuntimeBehavior(Loc, nullptr,
                        S.PDiag(diag::warn_stringcompare)
                            << isa<ObjCEncodeExpr>(LiteralStringStripped)
                            << LiteralString->getSourceRange());
}
12544}

12546static ImplicitConversionKind castKindToImplicitConversionKind(CastKind CK) {
switch (CK) {
default: {
12549#ifndef NDEBUG
  llvm::errs() << "unhandled cast kind: " << CastExpr::getCastKindName(CK)
               << "\n";
12552#endif
  llvm_unreachable("unhandled cast kind")::llvm::llvm_unreachable_internal("unhandled cast kind", "clang/lib/Sema/SemaExpr.cpp"
, 12553);
}
case CK_UserDefinedConversion:
  return ICK_Identity;
case CK_LValueToRValue:
  return ICK_Lvalue_To_Rvalue;
case CK_ArrayToPointerDecay:
  return ICK_Array_To_Pointer;
case CK_FunctionToPointerDecay:
  return ICK_Function_To_Pointer;
case CK_IntegralCast:
  return ICK_Integral_Conversion;
case CK_FloatingCast:
  return ICK_Floating_Conversion;
case CK_IntegralToFloating:
case CK_FloatingToIntegral:
  return ICK_Floating_Integral;
case CK_IntegralComplexCast:
case CK_FloatingComplexCast:
case CK_FloatingComplexToIntegralComplex:
case CK_IntegralComplexToFloatingComplex:
  return ICK_Complex_Conversion;
case CK_FloatingComplexToReal:
case CK_FloatingRealToComplex:
case CK_IntegralComplexToReal:
case CK_IntegralRealToComplex:
  return ICK_Complex_Real;
}
12581}

12583static bool checkThreeWayNarrowingConversion(Sema &S, QualType ToType, Expr *E,
                                           QualType FromType,
                                           SourceLocation Loc) {
// Check for a narrowing implicit conversion.
StandardConversionSequence SCS;
SCS.setAsIdentityConversion();
SCS.setToType(0, FromType);
SCS.setToType(1, ToType);
if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
  SCS.Second = castKindToImplicitConversionKind(ICE->getCastKind());

APValue PreNarrowingValue;
QualType PreNarrowingType;
switch (SCS.getNarrowingKind(S.Context, E, PreNarrowingValue,
                             PreNarrowingType,
                             /*IgnoreFloatToIntegralConversion*/ true)) {
case NK_Dependent_Narrowing:
  // Implicit conversion to a narrower type, but the expression is
  // value-dependent so we can't tell whether it's actually narrowing.
case NK_Not_Narrowing:
  return false;

case NK_Constant_Narrowing:
  // Implicit conversion to a narrower type, and the value is not a constant
  // expression.
  S.Diag(E->getBeginLoc(), diag::err_spaceship_argument_narrowing)
      << /*Constant*/ 1
      << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << ToType;
  return true;

case NK_Variable_Narrowing:
  // Implicit conversion to a narrower type, and the value is not a constant
  // expression.
case NK_Type_Narrowing:
  S.Diag(E->getBeginLoc(), diag::err_spaceship_argument_narrowing)
      << /*Constant*/ 0 << FromType << ToType;
  // TODO: It's not a constant expression, but what if the user intended it
  // to be? Can we produce notes to help them figure out why it isn't?
  return true;
}
llvm_unreachable("unhandled case in switch")::llvm::llvm_unreachable_internal("unhandled case in switch",
 "clang/lib/Sema/SemaExpr.cpp", 12623);
12624}

12626static QualType checkArithmeticOrEnumeralThreeWayCompare(Sema &S,
                                                       ExprResult &LHS,
                                                       ExprResult &RHS,
                                                       SourceLocation Loc) {
QualType LHSType = LHS.get()->getType();
QualType RHSType = RHS.get()->getType();
// Dig out the original argument type and expression before implicit casts
// were applied. These are the types/expressions we need to check the
// [expr.spaceship] requirements against.
ExprResult LHSStripped = LHS.get()->IgnoreParenImpCasts();
ExprResult RHSStripped = RHS.get()->IgnoreParenImpCasts();
QualType LHSStrippedType = LHSStripped.get()->getType();
QualType RHSStrippedType = RHSStripped.get()->getType();

// C++2a [expr.spaceship]p3: If one of the operands is of type bool and the
// other is not, the program is ill-formed.
if (LHSStrippedType->isBooleanType() != RHSStrippedType->isBooleanType()) {
  S.InvalidOperands(Loc, LHSStripped, RHSStripped);
  return QualType();
}

// FIXME: Consider combining this with checkEnumArithmeticConversions.
int NumEnumArgs = (int)LHSStrippedType->isEnumeralType() +
                  RHSStrippedType->isEnumeralType();
if (NumEnumArgs == 1) {
  bool LHSIsEnum = LHSStrippedType->isEnumeralType();
  QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
  if (OtherTy->hasFloatingRepresentation()) {
    S.InvalidOperands(Loc, LHSStripped, RHSStripped);
    return QualType();
  }
}
if (NumEnumArgs == 2) {
  // C++2a [expr.spaceship]p5: If both operands have the same enumeration
  // type E, the operator yields the result of converting the operands
  // to the underlying type of E and applying <=> to the converted operands.
  if (!S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) {
    S.InvalidOperands(Loc, LHS, RHS);
    return QualType();
  }
  QualType IntType =
      LHSStrippedType->castAs<EnumType>()->getDecl()->getIntegerType();
  assert(IntType->isArithmeticType())(static_cast <bool> (IntType->isArithmeticType()) ? void
 (0) : __assert_fail ("IntType->isArithmeticType()", "clang/lib/Sema/SemaExpr.cpp"
, 12668, __extension__ __PRETTY_FUNCTION__));

  // We can't use `CK_IntegralCast` when the underlying type is 'bool', so we
  // promote the boolean type, and all other promotable integer types, to
  // avoid this.
  if (S.Context.isPromotableIntegerType(IntType))
    IntType = S.Context.getPromotedIntegerType(IntType);

  LHS = S.ImpCastExprToType(LHS.get(), IntType, CK_IntegralCast);
  RHS = S.ImpCastExprToType(RHS.get(), IntType, CK_IntegralCast);
  LHSType = RHSType = IntType;
}

// C++2a [expr.spaceship]p4: If both operands have arithmetic types, the
// usual arithmetic conversions are applied to the operands.
QualType Type =
    S.UsualArithmeticConversions(LHS, RHS, Loc, Sema::ACK_Comparison);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();
if (Type.isNull())
  return S.InvalidOperands(Loc, LHS, RHS);

std::optional<ComparisonCategoryType> CCT =
    getComparisonCategoryForBuiltinCmp(Type);
if (!CCT)
  return S.InvalidOperands(Loc, LHS, RHS);

bool HasNarrowing = checkThreeWayNarrowingConversion(
    S, Type, LHS.get(), LHSType, LHS.get()->getBeginLoc());
HasNarrowing |= checkThreeWayNarrowingConversion(S, Type, RHS.get(), RHSType,
                                                 RHS.get()->getBeginLoc());
if (HasNarrowing)
  return QualType();

assert(!Type.isNull() && "composite type for <=> has not been set")(static_cast <bool> (!Type.isNull() && "composite type for <=> has not been set"
) ? void (0) : __assert_fail ("!Type.isNull() && \"composite type for <=> has not been set\""
, "clang/lib/Sema/SemaExpr.cpp", 12702, __extension__ __PRETTY_FUNCTION__
));

return S.CheckComparisonCategoryType(
    *CCT, Loc, Sema::ComparisonCategoryUsage::OperatorInExpression);
12706}

12708static QualType checkArithmeticOrEnumeralCompare(Sema &S, ExprResult &LHS,
                                               ExprResult &RHS,
                                               SourceLocation Loc,
                                               BinaryOperatorKind Opc) {
if (Opc == BO_Cmp)
  return checkArithmeticOrEnumeralThreeWayCompare(S, LHS, RHS, Loc);

// C99 6.5.8p3 / C99 6.5.9p4
QualType Type =
    S.UsualArithmeticConversions(LHS, RHS, Loc, Sema::ACK_Comparison);
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();
if (Type.isNull())
  return S.InvalidOperands(Loc, LHS, RHS);
assert(Type->isArithmeticType() || Type->isEnumeralType())(static_cast <bool> (Type->isArithmeticType() || Type
->isEnumeralType()) ? void (0) : __assert_fail ("Type->isArithmeticType() || Type->isEnumeralType()"
, "clang/lib/Sema/SemaExpr.cpp", 12722, __extension__ __PRETTY_FUNCTION__
));

if (Type->isAnyComplexType() && BinaryOperator::isRelationalOp(Opc))
  return S.InvalidOperands(Loc, LHS, RHS);

// Check for comparisons of floating point operands using != and ==.
if (Type->hasFloatingRepresentation())
  S.CheckFloatComparison(Loc, LHS.get(), RHS.get(), Opc);

// The result of comparisons is 'bool' in C++, 'int' in C.
return S.Context.getLogicalOperationType();
12733}

12735void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {
if (!NullE.get()->getType()->isAnyPointerType())
  return;
int NullValue = PP.isMacroDefined("NULL") ? 0 : 1;
if (!E.get()->getType()->isAnyPointerType() &&
    E.get()->isNullPointerConstant(Context,
                                   Expr::NPC_ValueDependentIsNotNull) ==
      Expr::NPCK_ZeroExpression) {
  if (const auto *CL = dyn_cast<CharacterLiteral>(E.get())) {
    if (CL->getValue() == 0)
      Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
          << NullValue
          << FixItHint::CreateReplacement(E.get()->getExprLoc(),
                                          NullValue ? "NULL" : "(void *)0");
  } else if (const auto *CE = dyn_cast<CStyleCastExpr>(E.get())) {
      TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
      QualType T = Context.getCanonicalType(TI->getType()).getUnqualifiedType();
      if (T == Context.CharTy)
        Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
            << NullValue
            << FixItHint::CreateReplacement(E.get()->getExprLoc(),
                                            NullValue ? "NULL" : "(void *)0");
    }
}
12759}

12761// C99 6.5.8, C++ [expr.rel]
12762QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
                                  SourceLocation Loc,
                                  BinaryOperatorKind Opc) {
bool IsRelational = BinaryOperator::isRelationalOp(Opc);
bool IsThreeWay = Opc == BO_Cmp;
bool IsOrdered = IsRelational || IsThreeWay;
auto IsAnyPointerType = [](ExprResult E) {
  QualType Ty = E.get()->getType();
  return Ty->isPointerType() || Ty->isMemberPointerType();
};

// C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
// type, array-to-pointer, ..., conversions are performed on both operands to
// bring them to their composite type.
// Otherwise, all comparisons expect an rvalue, so convert to rvalue before
// any type-related checks.
if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
  if (RHS.isInvalid())
    return QualType();
} else {
  LHS = DefaultLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
  RHS = DefaultLvalueConversion(RHS.get());
  if (RHS.isInvalid())
    return QualType();
}

checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/true);
if (!getLangOpts().CPlusPlus && BinaryOperator::isEqualityOp(Opc)) {
  CheckPtrComparisonWithNullChar(LHS, RHS);
  CheckPtrComparisonWithNullChar(RHS, LHS);
}

// Handle vector comparisons separately.
if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType())
  return CheckVectorCompareOperands(LHS, RHS, Loc, Opc);

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType())
  return CheckSizelessVectorCompareOperands(LHS, RHS, Loc, Opc);

diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);

QualType LHSType = LHS.get()->getType();
QualType RHSType = RHS.get()->getType();
if ((LHSType->isArithmeticType() || LHSType->isEnumeralType()) &&
    (RHSType->isArithmeticType() || RHSType->isEnumeralType()))
  return checkArithmeticOrEnumeralCompare(*this, LHS, RHS, Loc, Opc);

const Expr::NullPointerConstantKind LHSNullKind =
    LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
const Expr::NullPointerConstantKind RHSNullKind =
    RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;

auto computeResultTy = [&]() {
  if (Opc != BO_Cmp)
    return Context.getLogicalOperationType();
  assert(getLangOpts().CPlusPlus)(static_cast <bool> (getLangOpts().CPlusPlus) ? void (0
) : __assert_fail ("getLangOpts().CPlusPlus", "clang/lib/Sema/SemaExpr.cpp"
, 12828, __extension__ __PRETTY_FUNCTION__));
  assert(Context.hasSameType(LHS.get()->getType(), RHS.get()->getType()))(static_cast <bool> (Context.hasSameType(LHS.get()->
getType(), RHS.get()->getType())) ? void (0) : __assert_fail
 ("Context.hasSameType(LHS.get()->getType(), RHS.get()->getType())"
, "clang/lib/Sema/SemaExpr.cpp", 12829, __extension__ __PRETTY_FUNCTION__
));

  QualType CompositeTy = LHS.get()->getType();
  assert(!CompositeTy->isReferenceType())(static_cast <bool> (!CompositeTy->isReferenceType()
) ? void (0) : __assert_fail ("!CompositeTy->isReferenceType()"
, "clang/lib/Sema/SemaExpr.cpp", 12832, __extension__ __PRETTY_FUNCTION__
));

  std::optional<ComparisonCategoryType> CCT =
      getComparisonCategoryForBuiltinCmp(CompositeTy);
  if (!CCT)
    return InvalidOperands(Loc, LHS, RHS);

  if (CompositeTy->isPointerType() && LHSIsNull != RHSIsNull) {
    // P0946R0: Comparisons between a null pointer constant and an object
    // pointer result in std::strong_equality, which is ill-formed under
    // P1959R0.
    Diag(Loc, diag::err_typecheck_three_way_comparison_of_pointer_and_zero)
        << (LHSIsNull ? LHS.get()->getSourceRange()
                      : RHS.get()->getSourceRange());
    return QualType();
  }

  return CheckComparisonCategoryType(
      *CCT, Loc, ComparisonCategoryUsage::OperatorInExpression);
};

if (!IsOrdered && LHSIsNull != RHSIsNull) {
  bool IsEquality = Opc == BO_EQ;
  if (RHSIsNull)
    DiagnoseAlwaysNonNullPointer(LHS.get(), RHSNullKind, IsEquality,
                                 RHS.get()->getSourceRange());
  else
    DiagnoseAlwaysNonNullPointer(RHS.get(), LHSNullKind, IsEquality,
                                 LHS.get()->getSourceRange());
}

if (IsOrdered && LHSType->isFunctionPointerType() &&
    RHSType->isFunctionPointerType()) {
  // Valid unless a relational comparison of function pointers
  bool IsError = Opc == BO_Cmp;
  auto DiagID =
      IsError ? diag::err_typecheck_ordered_comparison_of_function_pointers
      : getLangOpts().CPlusPlus
          ? diag::warn_typecheck_ordered_comparison_of_function_pointers
          : diag::ext_typecheck_ordered_comparison_of_function_pointers;
  Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                    << RHS.get()->getSourceRange();
  if (IsError)
    return QualType();
}

if ((LHSType->isIntegerType() && !LHSIsNull) ||
    (RHSType->isIntegerType() && !RHSIsNull)) {
  // Skip normal pointer conversion checks in this case; we have better
  // diagnostics for this below.
} else if (getLangOpts().CPlusPlus) {
  // Equality comparison of a function pointer to a void pointer is invalid,
  // but we allow it as an extension.
  // FIXME: If we really want to allow this, should it be part of composite
  // pointer type computation so it works in conditionals too?
  if (!IsOrdered &&
      ((LHSType->isFunctionPointerType() && RHSType->isVoidPointerType()) ||
       (RHSType->isFunctionPointerType() && LHSType->isVoidPointerType()))) {
    // This is a gcc extension compatibility comparison.
    // In a SFINAE context, we treat this as a hard error to maintain
    // conformance with the C++ standard.
    diagnoseFunctionPointerToVoidComparison(
        *this, Loc, LHS, RHS, /*isError*/ (bool)isSFINAEContext());

    if (isSFINAEContext())
      return QualType();

    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
    return computeResultTy();
  }

  // C++ [expr.eq]p2:
  //   If at least one operand is a pointer [...] bring them to their
  //   composite pointer type.
  // C++ [expr.spaceship]p6
  //  If at least one of the operands is of pointer type, [...] bring them
  //  to their composite pointer type.
  // C++ [expr.rel]p2:
  //   If both operands are pointers, [...] bring them to their composite
  //   pointer type.
  // For <=>, the only valid non-pointer types are arrays and functions, and
  // we already decayed those, so this is really the same as the relational
  // comparison rule.
  if ((int)LHSType->isPointerType() + (int)RHSType->isPointerType() >=
          (IsOrdered ? 2 : 1) &&
      (!LangOpts.ObjCAutoRefCount || !(LHSType->isObjCObjectPointerType() ||
                                       RHSType->isObjCObjectPointerType()))) {
    if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
      return QualType();
    return computeResultTy();
  }
} else if (LHSType->isPointerType() &&
           RHSType->isPointerType()) { // C99 6.5.8p2
  // All of the following pointer-related warnings are GCC extensions, except
  // when handling null pointer constants.
  QualType LCanPointeeTy =
    LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
  QualType RCanPointeeTy =
    RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();

  // C99 6.5.9p2 and C99 6.5.8p2
  if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
                                 RCanPointeeTy.getUnqualifiedType())) {
    if (IsRelational) {
      // Pointers both need to point to complete or incomplete types
      if ((LCanPointeeTy->isIncompleteType() !=
           RCanPointeeTy->isIncompleteType()) &&
          !getLangOpts().C11) {
        Diag(Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
            << LHS.get()->getSourceRange() << RHS.get()->getSourceRange()
            << LHSType << RHSType << LCanPointeeTy->isIncompleteType()
            << RCanPointeeTy->isIncompleteType();
      }
    }
  } else if (!IsRelational &&
             (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
    // Valid unless comparison between non-null pointer and function pointer
    if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
        && !LHSIsNull && !RHSIsNull)
      diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
                                              /*isError*/false);
  } else {
    // Invalid
    diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
  }
  if (LCanPointeeTy != RCanPointeeTy) {
    // Treat NULL constant as a special case in OpenCL.
    if (getLangOpts().OpenCL && !LHSIsNull && !RHSIsNull) {
      if (!LCanPointeeTy.isAddressSpaceOverlapping(RCanPointeeTy)) {
        Diag(Loc,
             diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
            << LHSType << RHSType << 0 /* comparison */
            << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
      }
    }
    LangAS AddrSpaceL = LCanPointeeTy.getAddressSpace();
    LangAS AddrSpaceR = RCanPointeeTy.getAddressSpace();
    CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
                                             : CK_BitCast;
    if (LHSIsNull && !RHSIsNull)
      LHS = ImpCastExprToType(LHS.get(), RHSType, Kind);
    else
      RHS = ImpCastExprToType(RHS.get(), LHSType, Kind);
  }
  return computeResultTy();
}


// C++ [expr.eq]p4:
//   Two operands of type std::nullptr_t or one operand of type
//   std::nullptr_t and the other a null pointer constant compare
//   equal.
// C2x 6.5.9p5:
//   If both operands have type nullptr_t or one operand has type nullptr_t
//   and the other is a null pointer constant, they compare equal.
if (!IsOrdered && LHSIsNull && RHSIsNull) {
  if (LHSType->isNullPtrType()) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
    return computeResultTy();
  }
  if (RHSType->isNullPtrType()) {
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
    return computeResultTy();
  }
}

if (!getLangOpts().CPlusPlus && !IsOrdered && (LHSIsNull || RHSIsNull)) {
  // C2x 6.5.9p6:
  //   Otherwise, at least one operand is a pointer. If one is a pointer and
  //   the other is a null pointer constant, the null pointer constant is
  //   converted to the type of the pointer.
  if (LHSIsNull && RHSType->isPointerType()) {
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
    return computeResultTy();
  }
  if (RHSIsNull && LHSType->isPointerType()) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
    return computeResultTy();
  }
}

// Comparison of Objective-C pointers and block pointers against nullptr_t.
// These aren't covered by the composite pointer type rules.
if (!IsOrdered && RHSType->isNullPtrType() &&
    (LHSType->isObjCObjectPointerType() || LHSType->isBlockPointerType())) {
  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
  return computeResultTy();
}
if (!IsOrdered && LHSType->isNullPtrType() &&
    (RHSType->isObjCObjectPointerType() || RHSType->isBlockPointerType())) {
  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
  return computeResultTy();
}

if (getLangOpts().CPlusPlus) {
  if (IsRelational &&
      ((LHSType->isNullPtrType() && RHSType->isPointerType()) ||
       (RHSType->isNullPtrType() && LHSType->isPointerType()))) {
    // HACK: Relational comparison of nullptr_t against a pointer type is
    // invalid per DR583, but we allow it within std::less<> and friends,
    // since otherwise common uses of it break.
    // FIXME: Consider removing this hack once LWG fixes std::less<> and
    // friends to have std::nullptr_t overload candidates.
    DeclContext *DC = CurContext;
    if (isa<FunctionDecl>(DC))
      DC = DC->getParent();
    if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
      if (CTSD->isInStdNamespace() &&
          llvm::StringSwitch<bool>(CTSD->getName())
              .Cases("less", "less_equal", "greater", "greater_equal", true)
              .Default(false)) {
        if (RHSType->isNullPtrType())
          RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
        else
          LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
        return computeResultTy();
      }
    }
  }

  // C++ [expr.eq]p2:
  //   If at least one operand is a pointer to member, [...] bring them to
  //   their composite pointer type.
  if (!IsOrdered &&
      (LHSType->isMemberPointerType() || RHSType->isMemberPointerType())) {
    if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
      return QualType();
    else
      return computeResultTy();
  }
}

// Handle block pointer types.
if (!IsOrdered && LHSType->isBlockPointerType() &&
    RHSType->isBlockPointerType()) {
  QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType();
  QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType();

  if (!LHSIsNull && !RHSIsNull &&
      !Context.typesAreCompatible(lpointee, rpointee)) {
    Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
      << LHSType << RHSType << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();
  }
  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
  return computeResultTy();
}

// Allow block pointers to be compared with null pointer constants.
if (!IsOrdered
    && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
        || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
  if (!LHSIsNull && !RHSIsNull) {
    if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
           ->getPointeeType()->isVoidType())
          || (LHSType->isPointerType() && LHSType->castAs<PointerType>()
              ->getPointeeType()->isVoidType())))
      Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
        << LHSType << RHSType << LHS.get()->getSourceRange()
        << RHS.get()->getSourceRange();
  }
  if (LHSIsNull && !RHSIsNull)
    LHS = ImpCastExprToType(LHS.get(), RHSType,
                            RHSType->isPointerType() ? CK_BitCast
                              : CK_AnyPointerToBlockPointerCast);
  else
    RHS = ImpCastExprToType(RHS.get(), LHSType,
                            LHSType->isPointerType() ? CK_BitCast
                              : CK_AnyPointerToBlockPointerCast);
  return computeResultTy();
}

if (LHSType->isObjCObjectPointerType() ||
    RHSType->isObjCObjectPointerType()) {
  const PointerType *LPT = LHSType->getAs<PointerType>();
  const PointerType *RPT = RHSType->getAs<PointerType>();
  if (LPT || RPT) {
    bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false;
    bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false;

    if (!LPtrToVoid && !RPtrToVoid &&
        !Context.typesAreCompatible(LHSType, RHSType)) {
      diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
                                        /*isError*/false);
    }
    // FIXME: If LPtrToVoid, we should presumably convert the LHS rather than
    // the RHS, but we have test coverage for this behavior.
    // FIXME: Consider using convertPointersToCompositeType in C++.
    if (LHSIsNull && !RHSIsNull) {
      Expr *E = LHS.get();
      if (getLangOpts().ObjCAutoRefCount)
        CheckObjCConversion(SourceRange(), RHSType, E,
                            CCK_ImplicitConversion);
      LHS = ImpCastExprToType(E, RHSType,
                              RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
    }
    else {
      Expr *E = RHS.get();
      if (getLangOpts().ObjCAutoRefCount)
        CheckObjCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion,
                            /*Diagnose=*/true,
                            /*DiagnoseCFAudited=*/false, Opc);
      RHS = ImpCastExprToType(E, LHSType,
                              LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
    }
    return computeResultTy();
  }
  if (LHSType->isObjCObjectPointerType() &&
      RHSType->isObjCObjectPointerType()) {
    if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
      diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
                                        /*isError*/false);
    if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS))
      diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc);

    if (LHSIsNull && !RHSIsNull)
      LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
    else
      RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
    return computeResultTy();
  }

  if (!IsOrdered && LHSType->isBlockPointerType() &&
      RHSType->isBlockCompatibleObjCPointerType(Context)) {
    LHS = ImpCastExprToType(LHS.get(), RHSType,
                            CK_BlockPointerToObjCPointerCast);
    return computeResultTy();
  } else if (!IsOrdered &&
             LHSType->isBlockCompatibleObjCPointerType(Context) &&
             RHSType->isBlockPointerType()) {
    RHS = ImpCastExprToType(RHS.get(), LHSType,
                            CK_BlockPointerToObjCPointerCast);
    return computeResultTy();
  }
}
if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) ||
    (LHSType->isIntegerType() && RHSType->isAnyPointerType())) {
  unsigned DiagID = 0;
  bool isError = false;
  if (LangOpts.DebuggerSupport) {
    // Under a debugger, allow the comparison of pointers to integers,
    // since users tend to want to compare addresses.
  } else if ((LHSIsNull && LHSType->isIntegerType()) ||
             (RHSIsNull && RHSType->isIntegerType())) {
    if (IsOrdered) {
      isError = getLangOpts().CPlusPlus;
      DiagID =
        isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
                : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
    }
  } else if (getLangOpts().CPlusPlus) {
    DiagID = diag::err_typecheck_comparison_of_pointer_integer;
    isError = true;
  } else if (IsOrdered)
    DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
  else
    DiagID = diag::ext_typecheck_comparison_of_pointer_integer;

  if (DiagID) {
    Diag(Loc, DiagID)
      << LHSType << RHSType << LHS.get()->getSourceRange()
      << RHS.get()->getSourceRange();
    if (isError)
      return QualType();
  }

  if (LHSType->isIntegerType())
    LHS = ImpCastExprToType(LHS.get(), RHSType,
                      LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
  else
    RHS = ImpCastExprToType(RHS.get(), LHSType,
                      RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
  return computeResultTy();
}

// Handle block pointers.
if (!IsOrdered && RHSIsNull
    && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
  return computeResultTy();
}
if (!IsOrdered && LHSIsNull
    && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
  return computeResultTy();
}

if (getLangOpts().getOpenCLCompatibleVersion() >= 200) {
  if (LHSType->isClkEventT() && RHSType->isClkEventT()) {
    return computeResultTy();
  }

  if (LHSType->isQueueT() && RHSType->isQueueT()) {
    return computeResultTy();
  }

  if (LHSIsNull && RHSType->isQueueT()) {
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
    return computeResultTy();
  }

  if (LHSType->isQueueT() && RHSIsNull) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
    return computeResultTy();
  }
}

return InvalidOperands(Loc, LHS, RHS);
13240}

13242// Return a signed ext_vector_type that is of identical size and number of
13243// elements. For floating point vectors, return an integer type of identical
13244// size and number of elements. In the non ext_vector_type case, search from
13245// the largest type to the smallest type to avoid cases where long long == long,
13246// where long gets picked over long long.
13247QualType Sema::GetSignedVectorType(QualType V) {
const VectorType *VTy = V->castAs<VectorType>();
unsigned TypeSize = Context.getTypeSize(VTy->getElementType());

if (isa<ExtVectorType>(VTy)) {
  if (VTy->isExtVectorBoolType())
    return Context.getExtVectorType(Context.BoolTy, VTy->getNumElements());
  if (TypeSize == Context.getTypeSize(Context.CharTy))
    return Context.getExtVectorType(Context.CharTy, VTy->getNumElements());
  if (TypeSize == Context.getTypeSize(Context.ShortTy))
    return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements());
  if (TypeSize == Context.getTypeSize(Context.IntTy))
    return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
  if (TypeSize == Context.getTypeSize(Context.Int128Ty))
    return Context.getExtVectorType(Context.Int128Ty, VTy->getNumElements());
  if (TypeSize == Context.getTypeSize(Context.LongTy))
    return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
  assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&(static_cast <bool> (TypeSize == Context.getTypeSize(Context
.LongLongTy) && "Unhandled vector element size in vector compare"
) ? void (0) : __assert_fail ("TypeSize == Context.getTypeSize(Context.LongLongTy) && \"Unhandled vector element size in vector compare\""
, "clang/lib/Sema/SemaExpr.cpp", 13265, __extension__ __PRETTY_FUNCTION__
))
         "Unhandled vector element size in vector compare")(static_cast <bool> (TypeSize == Context.getTypeSize(Context
.LongLongTy) && "Unhandled vector element size in vector compare"
) ? void (0) : __assert_fail ("TypeSize == Context.getTypeSize(Context.LongLongTy) && \"Unhandled vector element size in vector compare\""
, "clang/lib/Sema/SemaExpr.cpp", 13265, __extension__ __PRETTY_FUNCTION__
));
  return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
}

if (TypeSize == Context.getTypeSize(Context.Int128Ty))
  return Context.getVectorType(Context.Int128Ty, VTy->getNumElements(),
                               VectorType::GenericVector);
if (TypeSize == Context.getTypeSize(Context.LongLongTy))
  return Context.getVectorType(Context.LongLongTy, VTy->getNumElements(),
                               VectorType::GenericVector);
if (TypeSize == Context.getTypeSize(Context.LongTy))
  return Context.getVectorType(Context.LongTy, VTy->getNumElements(),
                               VectorType::GenericVector);
if (TypeSize == Context.getTypeSize(Context.IntTy))
  return Context.getVectorType(Context.IntTy, VTy->getNumElements(),
                               VectorType::GenericVector);
if (TypeSize == Context.getTypeSize(Context.ShortTy))
  return Context.getVectorType(Context.ShortTy, VTy->getNumElements(),
                               VectorType::GenericVector);
assert(TypeSize == Context.getTypeSize(Context.CharTy) &&(static_cast <bool> (TypeSize == Context.getTypeSize(Context
.CharTy) && "Unhandled vector element size in vector compare"
) ? void (0) : __assert_fail ("TypeSize == Context.getTypeSize(Context.CharTy) && \"Unhandled vector element size in vector compare\""
, "clang/lib/Sema/SemaExpr.cpp", 13285, __extension__ __PRETTY_FUNCTION__
))
       "Unhandled vector element size in vector compare")(static_cast <bool> (TypeSize == Context.getTypeSize(Context
.CharTy) && "Unhandled vector element size in vector compare"
) ? void (0) : __assert_fail ("TypeSize == Context.getTypeSize(Context.CharTy) && \"Unhandled vector element size in vector compare\""
, "clang/lib/Sema/SemaExpr.cpp", 13285, __extension__ __PRETTY_FUNCTION__
));
return Context.getVectorType(Context.CharTy, VTy->getNumElements(),
                             VectorType::GenericVector);
13288}

13290QualType Sema::GetSignedSizelessVectorType(QualType V) {
const BuiltinType *VTy = V->castAs<BuiltinType>();
assert(VTy->isSizelessBuiltinType() && "expected sizeless type")(static_cast <bool> (VTy->isSizelessBuiltinType() &&
 "expected sizeless type") ? void (0) : __assert_fail ("VTy->isSizelessBuiltinType() && \"expected sizeless type\""
, "clang/lib/Sema/SemaExpr.cpp", 13292, __extension__ __PRETTY_FUNCTION__
));

const QualType ETy = V->getSveEltType(Context);
const auto TypeSize = Context.getTypeSize(ETy);

const QualType IntTy = Context.getIntTypeForBitwidth(TypeSize, true);
const llvm::ElementCount VecSize = Context.getBuiltinVectorTypeInfo(VTy).EC;
return Context.getScalableVectorType(IntTy, VecSize.getKnownMinValue());
13300}

13302/// CheckVectorCompareOperands - vector comparisons are a clang extension that
13303/// operates on extended vector types.  Instead of producing an IntTy result,
13304/// like a scalar comparison, a vector comparison produces a vector of integer
13305/// types.
13306QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
                                        SourceLocation Loc,
                                        BinaryOperatorKind Opc) {
if (Opc == BO_Cmp) {
  Diag(Loc, diag::err_three_way_vector_comparison);
  return QualType();
}

// Check to make sure we're operating on vectors of the same type and width,
// Allowing one side to be a scalar of element type.
QualType vType =
    CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/ false,
                        /*AllowBothBool*/ true,
                        /*AllowBoolConversions*/ getLangOpts().ZVector,
                        /*AllowBooleanOperation*/ true,
                        /*ReportInvalid*/ true);
if (vType.isNull())
  return vType;

QualType LHSType = LHS.get()->getType();

// Determine the return type of a vector compare. By default clang will return
// a scalar for all vector compares except vector bool and vector pixel.
// With the gcc compiler we will always return a vector type and with the xl
// compiler we will always return a scalar type. This switch allows choosing
// which behavior is prefered.
if (getLangOpts().AltiVec) {
  switch (getLangOpts().getAltivecSrcCompat()) {
  case LangOptions::AltivecSrcCompatKind::Mixed:
    // If AltiVec, the comparison results in a numeric type, i.e.
    // bool for C++, int for C
    if (vType->castAs<VectorType>()->getVectorKind() ==
        VectorType::AltiVecVector)
      return Context.getLogicalOperationType();
    else
      Diag(Loc, diag::warn_deprecated_altivec_src_compat);
    break;
  case LangOptions::AltivecSrcCompatKind::GCC:
    // For GCC we always return the vector type.
    break;
  case LangOptions::AltivecSrcCompatKind::XL:
    return Context.getLogicalOperationType();
    break;
  }
}

// For non-floating point types, check for self-comparisons of the form
// x == x, x != x, x < x, etc.  These always evaluate to a constant, and
// often indicate logic errors in the program.
diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);

// Check for comparisons of floating point operands using != and ==.
if (LHSType->hasFloatingRepresentation()) {
  assert(RHS.get()->getType()->hasFloatingRepresentation())(static_cast <bool> (RHS.get()->getType()->hasFloatingRepresentation
()) ? void (0) : __assert_fail ("RHS.get()->getType()->hasFloatingRepresentation()"
, "clang/lib/Sema/SemaExpr.cpp", 13359, __extension__ __PRETTY_FUNCTION__
));
  CheckFloatComparison(Loc, LHS.get(), RHS.get(), Opc);
}

// Return a signed type for the vector.
return GetSignedVectorType(vType);
13365}

13367QualType Sema::CheckSizelessVectorCompareOperands(ExprResult &LHS,
                                                ExprResult &RHS,
                                                SourceLocation Loc,
                                                BinaryOperatorKind Opc) {
if (Opc == BO_Cmp) {
  Diag(Loc, diag::err_three_way_vector_comparison);
  return QualType();
}

// Check to make sure we're operating on vectors of the same type and width,
// Allowing one side to be a scalar of element type.
QualType vType = CheckSizelessVectorOperands(
    LHS, RHS, Loc, /*isCompAssign*/ false, ACK_Comparison);

if (vType.isNull())
  return vType;

QualType LHSType = LHS.get()->getType();

// For non-floating point types, check for self-comparisons of the form
// x == x, x != x, x < x, etc.  These always evaluate to a constant, and
// often indicate logic errors in the program.
diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);

// Check for comparisons of floating point operands using != and ==.
if (LHSType->hasFloatingRepresentation()) {
  assert(RHS.get()->getType()->hasFloatingRepresentation())(static_cast <bool> (RHS.get()->getType()->hasFloatingRepresentation
()) ? void (0) : __assert_fail ("RHS.get()->getType()->hasFloatingRepresentation()"
, "clang/lib/Sema/SemaExpr.cpp", 13393, __extension__ __PRETTY_FUNCTION__
));
  CheckFloatComparison(Loc, LHS.get(), RHS.get(), Opc);
}

const BuiltinType *LHSBuiltinTy = LHSType->getAs<BuiltinType>();
const BuiltinType *RHSBuiltinTy = RHS.get()->getType()->getAs<BuiltinType>();

if (LHSBuiltinTy && RHSBuiltinTy && LHSBuiltinTy->isSVEBool() &&
    RHSBuiltinTy->isSVEBool())
  return LHSType;

// Return a signed type for the vector.
return GetSignedSizelessVectorType(vType);
13406}

13408static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS,
                                  const ExprResult &XorRHS,
                                  const SourceLocation Loc) {
// Do not diagnose macros.
if (Loc.isMacroID())
  return;

// Do not diagnose if both LHS and RHS are macros.
if (XorLHS.get()->getExprLoc().isMacroID() &&
    XorRHS.get()->getExprLoc().isMacroID())
  return;

bool Negative = false;
bool ExplicitPlus = false;
const auto *LHSInt = dyn_cast<IntegerLiteral>(XorLHS.get());
const auto *RHSInt = dyn_cast<IntegerLiteral>(XorRHS.get());

if (!LHSInt)
  return;
if (!RHSInt) {
  // Check negative literals.
  if (const auto *UO = dyn_cast<UnaryOperator>(XorRHS.get())) {
    UnaryOperatorKind Opc = UO->getOpcode();
    if (Opc != UO_Minus && Opc != UO_Plus)
      return;
    RHSInt = dyn_cast<IntegerLiteral>(UO->getSubExpr());
    if (!RHSInt)
      return;
    Negative = (Opc == UO_Minus);
    ExplicitPlus = !Negative;
  } else {
    return;
  }
}

const llvm::APInt &LeftSideValue = LHSInt->getValue();
llvm::APInt RightSideValue = RHSInt->getValue();
if (LeftSideValue != 2 && LeftSideValue != 10)
  return;

if (LeftSideValue.getBitWidth() != RightSideValue.getBitWidth())
  return;

CharSourceRange ExprRange = CharSourceRange::getCharRange(
    LHSInt->getBeginLoc(), S.getLocForEndOfToken(RHSInt->getLocation()));
llvm::StringRef ExprStr =
    Lexer::getSourceText(ExprRange, S.getSourceManager(), S.getLangOpts());

CharSourceRange XorRange =
    CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
llvm::StringRef XorStr =
    Lexer::getSourceText(XorRange, S.getSourceManager(), S.getLangOpts());
// Do not diagnose if xor keyword/macro is used.
if (XorStr == "xor")
  return;

std::string LHSStr = std::string(Lexer::getSourceText(
    CharSourceRange::getTokenRange(LHSInt->getSourceRange()),
    S.getSourceManager(), S.getLangOpts()));
std::string RHSStr = std::string(Lexer::getSourceText(
    CharSourceRange::getTokenRange(RHSInt->getSourceRange()),
    S.getSourceManager(), S.getLangOpts()));

if (Negative) {
  RightSideValue = -RightSideValue;
  RHSStr = "-" + RHSStr;
} else if (ExplicitPlus) {
  RHSStr = "+" + RHSStr;
}

StringRef LHSStrRef = LHSStr;
StringRef RHSStrRef = RHSStr;
// Do not diagnose literals with digit separators, binary, hexadecimal, octal
// literals.
if (LHSStrRef.startswith("0b") || LHSStrRef.startswith("0B") ||
    RHSStrRef.startswith("0b") || RHSStrRef.startswith("0B") ||
    LHSStrRef.startswith("0x") || LHSStrRef.startswith("0X") ||
    RHSStrRef.startswith("0x") || RHSStrRef.startswith("0X") ||
    (LHSStrRef.size() > 1 && LHSStrRef.startswith("0")) ||
    (RHSStrRef.size() > 1 && RHSStrRef.startswith("0")) ||
    LHSStrRef.contains('\'') || RHSStrRef.contains('\''))
  return;

bool SuggestXor =
    S.getLangOpts().CPlusPlus || S.getPreprocessor().isMacroDefined("xor");
const llvm::APInt XorValue = LeftSideValue ^ RightSideValue;
int64_t RightSideIntValue = RightSideValue.getSExtValue();
if (LeftSideValue == 2 && RightSideIntValue >= 0) {
  std::string SuggestedExpr = "1 << " + RHSStr;
  bool Overflow = false;
  llvm::APInt One = (LeftSideValue - 1);
  llvm::APInt PowValue = One.sshl_ov(RightSideValue, Overflow);
  if (Overflow) {
    if (RightSideIntValue < 64)
      S.Diag(Loc, diag::warn_xor_used_as_pow_base)
          << ExprStr << toString(XorValue, 10, true) << ("1LL << " + RHSStr)
          << FixItHint::CreateReplacement(ExprRange, "1LL << " + RHSStr);
    else if (RightSideIntValue == 64)
      S.Diag(Loc, diag::warn_xor_used_as_pow)
          << ExprStr << toString(XorValue, 10, true);
    else
      return;
  } else {
    S.Diag(Loc, diag::warn_xor_used_as_pow_base_extra)
        << ExprStr << toString(XorValue, 10, true) << SuggestedExpr
        << toString(PowValue, 10, true)
        << FixItHint::CreateReplacement(
               ExprRange, (RightSideIntValue == 0) ? "1" : SuggestedExpr);
  }

  S.Diag(Loc, diag::note_xor_used_as_pow_silence)
      << ("0x2 ^ " + RHSStr) << SuggestXor;
} else if (LeftSideValue == 10) {
  std::string SuggestedValue = "1e" + std::to_string(RightSideIntValue);
  S.Diag(Loc, diag::warn_xor_used_as_pow_base)
      << ExprStr << toString(XorValue, 10, true) << SuggestedValue
      << FixItHint::CreateReplacement(ExprRange, SuggestedValue);
  S.Diag(Loc, diag::note_xor_used_as_pow_silence)
      << ("0xA ^ " + RHSStr) << SuggestXor;
}
13528}

13530QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
                                        SourceLocation Loc) {
// Ensure that either both operands are of the same vector type, or
// one operand is of a vector type and the other is of its element type.
QualType vType = CheckVectorOperands(LHS, RHS, Loc, false,
                                     /*AllowBothBool*/ true,
                                     /*AllowBoolConversions*/ false,
                                     /*AllowBooleanOperation*/ false,
                                     /*ReportInvalid*/ false);
if (vType.isNull())
  return InvalidOperands(Loc, LHS, RHS);
if (getLangOpts().OpenCL &&
    getLangOpts().getOpenCLCompatibleVersion() < 120 &&
    vType->hasFloatingRepresentation())
  return InvalidOperands(Loc, LHS, RHS);
// FIXME: The check for C++ here is for GCC compatibility. GCC rejects the
//        usage of the logical operators && and || with vectors in C. This
//        check could be notionally dropped.
if (!getLangOpts().CPlusPlus &&
    !(isa<ExtVectorType>(vType->getAs<VectorType>())))
  return InvalidLogicalVectorOperands(Loc, LHS, RHS);

return GetSignedVectorType(LHS.get()->getType());
13553}

13555QualType Sema::CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
                                            SourceLocation Loc,
                                            bool IsCompAssign) {
if (!IsCompAssign) {
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}
RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
  return QualType();

// For conversion purposes, we ignore any qualifiers.
// For example, "const float" and "float" are equivalent.
QualType LHSType = LHS.get()->getType().getUnqualifiedType();
QualType RHSType = RHS.get()->getType().getUnqualifiedType();

const MatrixType *LHSMatType = LHSType->getAs<MatrixType>();
const MatrixType *RHSMatType = RHSType->getAs<MatrixType>();
assert((LHSMatType || RHSMatType) && "At least one operand must be a matrix")(static_cast <bool> ((LHSMatType || RHSMatType) &&
 "At least one operand must be a matrix") ? void (0) : __assert_fail
 ("(LHSMatType || RHSMatType) && \"At least one operand must be a matrix\""
, "clang/lib/Sema/SemaExpr.cpp", 13574, __extension__ __PRETTY_FUNCTION__
));

if (Context.hasSameType(LHSType, RHSType))
  return Context.getCommonSugaredType(LHSType, RHSType);

// Type conversion may change LHS/RHS. Keep copies to the original results, in
// case we have to return InvalidOperands.
ExprResult OriginalLHS = LHS;
ExprResult OriginalRHS = RHS;
if (LHSMatType && !RHSMatType) {
  RHS = tryConvertExprToType(RHS.get(), LHSMatType->getElementType());
  if (!RHS.isInvalid())
    return LHSType;

  return InvalidOperands(Loc, OriginalLHS, OriginalRHS);
}

if (!LHSMatType && RHSMatType) {
  LHS = tryConvertExprToType(LHS.get(), RHSMatType->getElementType());
  if (!LHS.isInvalid())
    return RHSType;
  return InvalidOperands(Loc, OriginalLHS, OriginalRHS);
}

return InvalidOperands(Loc, LHS, RHS);
13599}

13601QualType Sema::CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
                                         SourceLocation Loc,
                                         bool IsCompAssign) {
if (!IsCompAssign) {
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}
RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
  return QualType();

auto *LHSMatType = LHS.get()->getType()->getAs<ConstantMatrixType>();
auto *RHSMatType = RHS.get()->getType()->getAs<ConstantMatrixType>();
assert((LHSMatType || RHSMatType) && "At least one operand must be a matrix")(static_cast <bool> ((LHSMatType || RHSMatType) &&
 "At least one operand must be a matrix") ? void (0) : __assert_fail
 ("(LHSMatType || RHSMatType) && \"At least one operand must be a matrix\""
, "clang/lib/Sema/SemaExpr.cpp", 13615, __extension__ __PRETTY_FUNCTION__
));

if (LHSMatType && RHSMatType) {
  if (LHSMatType->getNumColumns() != RHSMatType->getNumRows())
    return InvalidOperands(Loc, LHS, RHS);

  if (Context.hasSameType(LHSMatType, RHSMatType))
    return Context.getCommonSugaredType(
        LHS.get()->getType().getUnqualifiedType(),
        RHS.get()->getType().getUnqualifiedType());

  QualType LHSELTy = LHSMatType->getElementType(),
           RHSELTy = RHSMatType->getElementType();
  if (!Context.hasSameType(LHSELTy, RHSELTy))
    return InvalidOperands(Loc, LHS, RHS);

  return Context.getConstantMatrixType(
      Context.getCommonSugaredType(LHSELTy, RHSELTy),
      LHSMatType->getNumRows(), RHSMatType->getNumColumns());
}
return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);
13636}

13638static bool isLegalBoolVectorBinaryOp(BinaryOperatorKind Opc) {
switch (Opc) {
default:
  return false;
case BO_And:
case BO_AndAssign:
case BO_Or:
case BO_OrAssign:
case BO_Xor:
case BO_XorAssign:
  return true;
}
13650}

13652inline QualType Sema::CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS,
                                         SourceLocation Loc,
                                         BinaryOperatorKind Opc) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);

bool IsCompAssign =
    Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;

bool LegalBoolVecOperator = isLegalBoolVectorBinaryOp(Opc);

if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType()) {
  if (LHS.get()->getType()->hasIntegerRepresentation() &&
      RHS.get()->getType()->hasIntegerRepresentation())
    return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                               /*AllowBothBool*/ true,
                               /*AllowBoolConversions*/ getLangOpts().ZVector,
                               /*AllowBooleanOperation*/ LegalBoolVecOperator,
                               /*ReportInvalid*/ true);
  return InvalidOperands(Loc, LHS, RHS);
}

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType()) {
  if (LHS.get()->getType()->hasIntegerRepresentation() &&
      RHS.get()->getType()->hasIntegerRepresentation())
    return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                       ACK_BitwiseOp);
  return InvalidOperands(Loc, LHS, RHS);
}

if (LHS.get()->getType()->isVLSTBuiltinType() ||
    RHS.get()->getType()->isVLSTBuiltinType()) {
  if (LHS.get()->getType()->hasIntegerRepresentation() &&
      RHS.get()->getType()->hasIntegerRepresentation())
    return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                       ACK_BitwiseOp);
  return InvalidOperands(Loc, LHS, RHS);
}

if (Opc == BO_And)
  diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);

if (LHS.get()->getType()->hasFloatingRepresentation() ||
    RHS.get()->getType()->hasFloatingRepresentation())
  return InvalidOperands(Loc, LHS, RHS);

ExprResult LHSResult = LHS, RHSResult = RHS;
QualType compType = UsualArithmeticConversions(
    LHSResult, RHSResult, Loc, IsCompAssign ? ACK_CompAssign : ACK_BitwiseOp);
if (LHSResult.isInvalid() || RHSResult.isInvalid())
  return QualType();
LHS = LHSResult.get();
RHS = RHSResult.get();

if (Opc == BO_Xor)
  diagnoseXorMisusedAsPow(*this, LHS, RHS, Loc);

if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType())
  return compType;
return InvalidOperands(Loc, LHS, RHS);
13713}

13715// C99 6.5.[13,14]
13716inline QualType Sema::CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS,
                                         SourceLocation Loc,
                                         BinaryOperatorKind Opc) {
// Check vector operands differently.
if (LHS.get()->getType()->isVectorType() ||
    RHS.get()->getType()->isVectorType())
  return CheckVectorLogicalOperands(LHS, RHS, Loc);

bool EnumConstantInBoolContext = false;
for (const ExprResult &HS : {LHS, RHS}) {
  if (const auto *DREHS = dyn_cast<DeclRefExpr>(HS.get())) {
    const auto *ECDHS = dyn_cast<EnumConstantDecl>(DREHS->getDecl());
    if (ECDHS && ECDHS->getInitVal() != 0 && ECDHS->getInitVal() != 1)
      EnumConstantInBoolContext = true;
  }
}

if (EnumConstantInBoolContext)
  Diag(Loc, diag::warn_enum_constant_in_bool_context);

// Diagnose cases where the user write a logical and/or but probably meant a
// bitwise one.  We do this when the LHS is a non-bool integer and the RHS
// is a constant.
if (!EnumConstantInBoolContext && LHS.get()->getType()->isIntegerType() &&
    !LHS.get()->getType()->isBooleanType() &&
    RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() &&
    // Don't warn in macros or template instantiations.
    !Loc.isMacroID() && !inTemplateInstantiation()) {
  // If the RHS can be constant folded, and if it constant folds to something
  // that isn't 0 or 1 (which indicate a potential logical operation that
  // happened to fold to true/false) then warn.
  // Parens on the RHS are ignored.
  Expr::EvalResult EVResult;
  if (RHS.get()->EvaluateAsInt(EVResult, Context)) {
    llvm::APSInt Result = EVResult.Val.getInt();
    if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType() &&
         !RHS.get()->getExprLoc().isMacroID()) ||
        (Result != 0 && Result != 1)) {
      Diag(Loc, diag::warn_logical_instead_of_bitwise)
          << RHS.get()->getSourceRange() << (Opc == BO_LAnd ? "&&" : "||");
      // Suggest replacing the logical operator with the bitwise version
      Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
          << (Opc == BO_LAnd ? "&" : "|")
          << FixItHint::CreateReplacement(
                 SourceRange(Loc, getLocForEndOfToken(Loc)),
                 Opc == BO_LAnd ? "&" : "|");
      if (Opc == BO_LAnd)
        // Suggest replacing "Foo() && kNonZero" with "Foo()"
        Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
            << FixItHint::CreateRemoval(
                   SourceRange(getLocForEndOfToken(LHS.get()->getEndLoc()),
                               RHS.get()->getEndLoc()));
    }
  }
}

if (!Context.getLangOpts().CPlusPlus) {
  // OpenCL v1.1 s6.3.g: The logical operators and (&&), or (||) do
  // not operate on the built-in scalar and vector float types.
  if (Context.getLangOpts().OpenCL &&
      Context.getLangOpts().OpenCLVersion < 120) {
    if (LHS.get()->getType()->isFloatingType() ||
        RHS.get()->getType()->isFloatingType())
      return InvalidOperands(Loc, LHS, RHS);
  }

  LHS = UsualUnaryConversions(LHS.get());
  if (LHS.isInvalid())
    return QualType();

  RHS = UsualUnaryConversions(RHS.get());
  if (RHS.isInvalid())
    return QualType();

  if (!LHS.get()->getType()->isScalarType() ||
      !RHS.get()->getType()->isScalarType())
    return InvalidOperands(Loc, LHS, RHS);

  return Context.IntTy;
}

// The following is safe because we only use this method for
// non-overloadable operands.

// C++ [expr.log.and]p1
// C++ [expr.log.or]p1
// The operands are both contextually converted to type bool.
ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get());
if (LHSRes.isInvalid())
  return InvalidOperands(Loc, LHS, RHS);
LHS = LHSRes;

ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get());
if (RHSRes.isInvalid())
  return InvalidOperands(Loc, LHS, RHS);
RHS = RHSRes;

// C++ [expr.log.and]p2
// C++ [expr.log.or]p2
// The result is a bool.
return Context.BoolTy;
13817}

13819static bool IsReadonlyMessage(Expr *E, Sema &S) {
const MemberExpr *ME = dyn_cast<MemberExpr>(E);
if (!ME) return false;
if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
ObjCMessageExpr *Base = dyn_cast<ObjCMessageExpr>(
    ME->getBase()->IgnoreImplicit()->IgnoreParenImpCasts());
if (!Base) return false;
return Base->getMethodDecl() != nullptr;
13827}

13829/// Is the given expression (which must be 'const') a reference to a
13830/// variable which was originally non-const, but which has become
13831/// 'const' due to being captured within a block?
13832enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda };
13833static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
assert(E->isLValue() && E->getType().isConstQualified())(static_cast <bool> (E->isLValue() && E->
getType().isConstQualified()) ? void (0) : __assert_fail ("E->isLValue() && E->getType().isConstQualified()"
, "clang/lib/Sema/SemaExpr.cpp", 13834, __extension__ __PRETTY_FUNCTION__
));
E = E->IgnoreParens();

// Must be a reference to a declaration from an enclosing scope.
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
if (!DRE) return NCCK_None;
if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None;

// The declaration must be a variable which is not declared 'const'.
VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
if (!var) return NCCK_None;
if (var->getType().isConstQualified()) return NCCK_None;
assert(var->hasLocalStorage() && "capture added 'const' to non-local?")(static_cast <bool> (var->hasLocalStorage() &&
 "capture added 'const' to non-local?") ? void (0) : __assert_fail
 ("var->hasLocalStorage() && \"capture added 'const' to non-local?\""
, "clang/lib/Sema/SemaExpr.cpp", 13846, __extension__ __PRETTY_FUNCTION__
));

// Decide whether the first capture was for a block or a lambda.
DeclContext *DC = S.CurContext, *Prev = nullptr;
// Decide whether the first capture was for a block or a lambda.
while (DC) {
  // For init-capture, it is possible that the variable belongs to the
  // template pattern of the current context.
  if (auto *FD = dyn_cast<FunctionDecl>(DC))
    if (var->isInitCapture() &&
        FD->getTemplateInstantiationPattern() == var->getDeclContext())
      break;
  if (DC == var->getDeclContext())
    break;
  Prev = DC;
  DC = DC->getParent();
}
// Unless we have an init-capture, we've gone one step too far.
if (!var->isInitCapture())
  DC = Prev;
return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda);
13867}

13869static bool IsTypeModifiable(QualType Ty, bool IsDereference) {
Ty = Ty.getNonReferenceType();
if (IsDereference && Ty->isPointerType())
  Ty = Ty->getPointeeType();
return !Ty.isConstQualified();
13874}

13876// Update err_typecheck_assign_const and note_typecheck_assign_const
13877// when this enum is changed.
13878enum {
ConstFunction,
ConstVariable,
ConstMember,
ConstMethod,
NestedConstMember,
ConstUnknown,  // Keep as last element
13885};

13887/// Emit the "read-only variable not assignable" error and print notes to give
13888/// more information about why the variable is not assignable, such as pointing
13889/// to the declaration of a const variable, showing that a method is const, or
13890/// that the function is returning a const reference.
13891static void DiagnoseConstAssignment(Sema &S, const Expr *E,
                                  SourceLocation Loc) {
SourceRange ExprRange = E->getSourceRange();

// Only emit one error on the first const found.  All other consts will emit
// a note to the error.
bool DiagnosticEmitted = false;

// Track if the current expression is the result of a dereference, and if the
// next checked expression is the result of a dereference.
bool IsDereference = false;
bool NextIsDereference = false;

// Loop to process MemberExpr chains.
while (true) {
  IsDereference = NextIsDereference;

  E = E->IgnoreImplicit()->IgnoreParenImpCasts();
  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
    NextIsDereference = ME->isArrow();
    const ValueDecl *VD = ME->getMemberDecl();
    if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
      // Mutable fields can be modified even if the class is const.
      if (Field->isMutable()) {
        assert(DiagnosticEmitted && "Expected diagnostic not emitted.")(static_cast <bool> (DiagnosticEmitted && "Expected diagnostic not emitted."
) ? void (0) : __assert_fail ("DiagnosticEmitted && \"Expected diagnostic not emitted.\""
, "clang/lib/Sema/SemaExpr.cpp", 13915, __extension__ __PRETTY_FUNCTION__
));
        break;
      }

      if (!IsTypeModifiable(Field->getType(), IsDereference)) {
        if (!DiagnosticEmitted) {
          S.Diag(Loc, diag::err_typecheck_assign_const)
              << ExprRange << ConstMember << false /*static*/ << Field
              << Field->getType();
          DiagnosticEmitted = true;
        }
        S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
            << ConstMember << false /*static*/ << Field << Field->getType()
            << Field->getSourceRange();
      }
      E = ME->getBase();
      continue;
    } else if (const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
      if (VDecl->getType().isConstQualified()) {
        if (!DiagnosticEmitted) {
          S.Diag(Loc, diag::err_typecheck_assign_const)
              << ExprRange << ConstMember << true /*static*/ << VDecl
              << VDecl->getType();
          DiagnosticEmitted = true;
        }
        S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
            << ConstMember << true /*static*/ << VDecl << VDecl->getType()
            << VDecl->getSourceRange();
      }
      // Static fields do not inherit constness from parents.
      break;
    }
    break; // End MemberExpr
  } else if (const ArraySubscriptExpr *ASE =
                 dyn_cast<ArraySubscriptExpr>(E)) {
    E = ASE->getBase()->IgnoreParenImpCasts();
    continue;
  } else if (const ExtVectorElementExpr *EVE =
                 dyn_cast<ExtVectorElementExpr>(E)) {
    E = EVE->getBase()->IgnoreParenImpCasts();
    continue;
  }
  break;
}

if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
  // Function calls
  const FunctionDecl *FD = CE->getDirectCallee();
  if (FD && !IsTypeModifiable(FD->getReturnType(), IsDereference)) {
    if (!DiagnosticEmitted) {
      S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
                                                    << ConstFunction << FD;
      DiagnosticEmitted = true;
    }
    S.Diag(FD->getReturnTypeSourceRange().getBegin(),
           diag::note_typecheck_assign_const)
        << ConstFunction << FD << FD->getReturnType()
        << FD->getReturnTypeSourceRange();
  }
} else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
  // Point to variable declaration.
  if (const ValueDecl *VD = DRE->getDecl()) {
    if (!IsTypeModifiable(VD->getType(), IsDereference)) {
      if (!DiagnosticEmitted) {
        S.Diag(Loc, diag::err_typecheck_assign_const)
            << ExprRange << ConstVariable << VD << VD->getType();
        DiagnosticEmitted = true;
      }
      S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
          << ConstVariable << VD << VD->getType() << VD->getSourceRange();
    }
  }
} else if (isa<CXXThisExpr>(E)) {
  if (const DeclContext *DC = S.getFunctionLevelDeclContext()) {
    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
      if (MD->isConst()) {
        if (!DiagnosticEmitted) {
          S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
                                                        << ConstMethod << MD;
          DiagnosticEmitted = true;
        }
        S.Diag(MD->getLocation(), diag::note_typecheck_assign_const)
            << ConstMethod << MD << MD->getSourceRange();
      }
    }
  }
}

if (DiagnosticEmitted)
  return;

// Can't determine a more specific message, so display the generic error.
S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange << ConstUnknown;
14008}

14010enum OriginalExprKind {
OEK_Variable,
OEK_Member,
OEK_LValue
14014};

14016static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD,
                                       const RecordType *Ty,
                                       SourceLocation Loc, SourceRange Range,
                                       OriginalExprKind OEK,
                                       bool &DiagnosticEmitted) {
std::vector<const RecordType *> RecordTypeList;
RecordTypeList.push_back(Ty);
unsigned NextToCheckIndex = 0;
// We walk the record hierarchy breadth-first to ensure that we print
// diagnostics in field nesting order.
while (RecordTypeList.size() > NextToCheckIndex) {
  bool IsNested = NextToCheckIndex > 0;
  for (const FieldDecl *Field :
       RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
    // First, check every field for constness.
    QualType FieldTy = Field->getType();
    if (FieldTy.isConstQualified()) {
      if (!DiagnosticEmitted) {
        S.Diag(Loc, diag::err_typecheck_assign_const)
            << Range << NestedConstMember << OEK << VD
            << IsNested << Field;
        DiagnosticEmitted = true;
      }
      S.Diag(Field->getLocation(), diag::note_typecheck_assign_const)
          << NestedConstMember << IsNested << Field
          << FieldTy << Field->getSourceRange();
    }

    // Then we append it to the list to check next in order.
    FieldTy = FieldTy.getCanonicalType();
    if (const auto *FieldRecTy = FieldTy->getAs<RecordType>()) {
      if (!llvm::is_contained(RecordTypeList, FieldRecTy))
        RecordTypeList.push_back(FieldRecTy);
    }
  }
  ++NextToCheckIndex;
}
14053}

14055/// Emit an error for the case where a record we are trying to assign to has a
14056/// const-qualified field somewhere in its hierarchy.
14057static void DiagnoseRecursiveConstFields(Sema &S, const Expr *E,
                                       SourceLocation Loc) {
QualType Ty = E->getType();
assert(Ty->isRecordType() && "lvalue was not record?")(static_cast <bool> (Ty->isRecordType() && "lvalue was not record?"
) ? void (0) : __assert_fail ("Ty->isRecordType() && \"lvalue was not record?\""
, "clang/lib/Sema/SemaExpr.cpp", 14060, __extension__ __PRETTY_FUNCTION__
));
SourceRange Range = E->getSourceRange();
const RecordType *RTy = Ty.getCanonicalType()->getAs<RecordType>();
bool DiagEmitted = false;

if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
  DiagnoseRecursiveConstFields(S, ME->getMemberDecl(), RTy, Loc,
          Range, OEK_Member, DiagEmitted);
else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
  DiagnoseRecursiveConstFields(S, DRE->getDecl(), RTy, Loc,
          Range, OEK_Variable, DiagEmitted);
else
  DiagnoseRecursiveConstFields(S, nullptr, RTy, Loc,
          Range, OEK_LValue, DiagEmitted);
if (!DiagEmitted)
  DiagnoseConstAssignment(S, E, Loc);
14076}

14078/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue.  If not,
14079/// emit an error and return true.  If so, return false.
14080static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
assert(!E->hasPlaceholderType(BuiltinType::PseudoObject))(static_cast <bool> (!E->hasPlaceholderType(BuiltinType
::PseudoObject)) ? void (0) : __assert_fail ("!E->hasPlaceholderType(BuiltinType::PseudoObject)"
, "clang/lib/Sema/SemaExpr.cpp", 14081, __extension__ __PRETTY_FUNCTION__
));

S.CheckShadowingDeclModification(E, Loc);

SourceLocation OrigLoc = Loc;
Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
                                                            &Loc);
if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
  IsLV = Expr::MLV_InvalidMessageExpression;
if (IsLV == Expr::MLV_Valid)
  return false;

unsigned DiagID = 0;
bool NeedType = false;
switch (IsLV) { // C99 6.5.16p2
case Expr::MLV_ConstQualified:
  // Use a specialized diagnostic when we're assigning to an object
  // from an enclosing function or block.
  if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) {
    if (NCCK == NCCK_Block)
      DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
    else
      DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
    break;
  }

  // In ARC, use some specialized diagnostics for occasions where we
  // infer 'const'.  These are always pseudo-strong variables.
  if (S.getLangOpts().ObjCAutoRefCount) {
    DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts());
    if (declRef && isa<VarDecl>(declRef->getDecl())) {
      VarDecl *var = cast<VarDecl>(declRef->getDecl());

      // Use the normal diagnostic if it's pseudo-__strong but the
      // user actually wrote 'const'.
      if (var->isARCPseudoStrong() &&
          (!var->getTypeSourceInfo() ||
           !var->getTypeSourceInfo()->getType().isConstQualified())) {
        // There are three pseudo-strong cases:
        //  - self
        ObjCMethodDecl *method = S.getCurMethodDecl();
        if (method && var == method->getSelfDecl()) {
          DiagID = method->isClassMethod()
            ? diag::err_typecheck_arc_assign_self_class_method
            : diag::err_typecheck_arc_assign_self;

        //  - Objective-C externally_retained attribute.
        } else if (var->hasAttr<ObjCExternallyRetainedAttr>() ||
                   isa<ParmVarDecl>(var)) {
          DiagID = diag::err_typecheck_arc_assign_externally_retained;

        //  - fast enumeration variables
        } else {
          DiagID = diag::err_typecheck_arr_assign_enumeration;
        }

        SourceRange Assign;
        if (Loc != OrigLoc)
          Assign = SourceRange(OrigLoc, OrigLoc);
        S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
        // We need to preserve the AST regardless, so migration tool
        // can do its job.
        return false;
      }
    }
  }

  // If none of the special cases above are triggered, then this is a
  // simple const assignment.
  if (DiagID == 0) {
    DiagnoseConstAssignment(S, E, Loc);
    return true;
  }

  break;
case Expr::MLV_ConstAddrSpace:
  DiagnoseConstAssignment(S, E, Loc);
  return true;
case Expr::MLV_ConstQualifiedField:
  DiagnoseRecursiveConstFields(S, E, Loc);
  return true;
case Expr::MLV_ArrayType:
case Expr::MLV_ArrayTemporary:
  DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
  NeedType = true;
  break;
case Expr::MLV_NotObjectType:
  DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
  NeedType = true;
  break;
case Expr::MLV_LValueCast:
  DiagID = diag::err_typecheck_lvalue_casts_not_supported;
  break;
case Expr::MLV_Valid:
  llvm_unreachable("did not take early return for MLV_Valid")::llvm::llvm_unreachable_internal("did not take early return for MLV_Valid"
, "clang/lib/Sema/SemaExpr.cpp", 14175);
case Expr::MLV_InvalidExpression:
case Expr::MLV_MemberFunction:
case Expr::MLV_ClassTemporary:
  DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
  break;
case Expr::MLV_IncompleteType:
case Expr::MLV_IncompleteVoidType:
  return S.RequireCompleteType(Loc, E->getType(),
           diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
case Expr::MLV_DuplicateVectorComponents:
  DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
  break;
case Expr::MLV_NoSetterProperty:
  llvm_unreachable("readonly properties should be processed differently")::llvm::llvm_unreachable_internal("readonly properties should be processed differently"
, "clang/lib/Sema/SemaExpr.cpp", 14189);
case Expr::MLV_InvalidMessageExpression:
  DiagID = diag::err_readonly_message_assignment;
  break;
case Expr::MLV_SubObjCPropertySetting:
  DiagID = diag::err_no_subobject_property_setting;
  break;
}

SourceRange Assign;
if (Loc != OrigLoc)
  Assign = SourceRange(OrigLoc, OrigLoc);
if (NeedType)
  S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign;
else
  S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
return true;
14206}

14208static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
                                       SourceLocation Loc,
                                       Sema &Sema) {
if (Sema.inTemplateInstantiation())
  return;
if (Sema.isUnevaluatedContext())
  return;
if (Loc.isInvalid() || Loc.isMacroID())
  return;
if (LHSExpr->getExprLoc().isMacroID() || RHSExpr->getExprLoc().isMacroID())
  return;

// C / C++ fields
MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
if (ML && MR) {
  if (!(isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase())))
    return;
  const ValueDecl *LHSDecl =
      cast<ValueDecl>(ML->getMemberDecl()->getCanonicalDecl());
  const ValueDecl *RHSDecl =
      cast<ValueDecl>(MR->getMemberDecl()->getCanonicalDecl());
  if (LHSDecl != RHSDecl)
    return;
  if (LHSDecl->getType().isVolatileQualified())
    return;
  if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
    if (RefTy->getPointeeType().isVolatileQualified())
      return;

  Sema.Diag(Loc, diag::warn_identity_field_assign) << 0;
}

// Objective-C instance variables
ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr);
ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr);
if (OL && OR && OL->getDecl() == OR->getDecl()) {
  DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts());
  DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts());
  if (RL && RR && RL->getDecl() == RR->getDecl())
    Sema.Diag(Loc, diag::warn_identity_field_assign) << 1;
}
14250}

14252// C99 6.5.16.1
14253QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
                                     SourceLocation Loc,
                                     QualType CompoundType,
                                     BinaryOperatorKind Opc) {
assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject))(static_cast <bool> (!LHSExpr->hasPlaceholderType(BuiltinType
::PseudoObject)) ? void (0) : __assert_fail ("!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject)"
, "clang/lib/Sema/SemaExpr.cpp", 14257, __extension__ __PRETTY_FUNCTION__
));

// Verify that LHS is a modifiable lvalue, and emit error if not.
if (CheckForModifiableLvalue(LHSExpr, Loc, *this))
  return QualType();

QualType LHSType = LHSExpr->getType();
QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
                                           CompoundType;
// OpenCL v1.2 s6.1.1.1 p2:
// The half data type can only be used to declare a pointer to a buffer that
// contains half values
if (getLangOpts().OpenCL &&
    !getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&
    LHSType->isHalfType()) {
  Diag(Loc, diag::err_opencl_half_load_store) << 1
      << LHSType.getUnqualifiedType();
  return QualType();
}

AssignConvertType ConvTy;
if (CompoundType.isNull()) {
  Expr *RHSCheck = RHS.get();

  CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this);

  QualType LHSTy(LHSType);
  ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
  if (RHS.isInvalid())
    return QualType();
  // Special case of NSObject attributes on c-style pointer types.
  if (ConvTy == IncompatiblePointer &&
      ((Context.isObjCNSObjectType(LHSType) &&
        RHSType->isObjCObjectPointerType()) ||
       (Context.isObjCNSObjectType(RHSType) &&
        LHSType->isObjCObjectPointerType())))
    ConvTy = Compatible;

  if (ConvTy == Compatible &&
      LHSType->isObjCObjectType())
      Diag(Loc, diag::err_objc_object_assignment)
        << LHSType;

  // If the RHS is a unary plus or minus, check to see if they = and + are
  // right next to each other.  If so, the user may have typo'd "x =+ 4"
  // instead of "x += 4".
  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
    RHSCheck = ICE->getSubExpr();
  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
    if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
        Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
        // Only if the two operators are exactly adjacent.
        Loc.getLocWithOffset(1) == UO->getOperatorLoc() &&
        // And there is a space or other character before the subexpr of the
        // unary +/-.  We don't want to warn on "x=-1".
        Loc.getLocWithOffset(2) != UO->getSubExpr()->getBeginLoc() &&
        UO->getSubExpr()->getBeginLoc().isFileID()) {
      Diag(Loc, diag::warn_not_compound_assign)
        << (UO->getOpcode() == UO_Plus ? "+" : "-")
        << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
    }
  }

  if (ConvTy == Compatible) {
    if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) {
      // Warn about retain cycles where a block captures the LHS, but
      // not if the LHS is a simple variable into which the block is
      // being stored...unless that variable can be captured by reference!
      const Expr *InnerLHS = LHSExpr->IgnoreParenCasts();
      const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
      if (!DRE || DRE->getDecl()->hasAttr<BlocksAttr>())
        checkRetainCycles(LHSExpr, RHS.get());
    }

    if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong ||
        LHSType.isNonWeakInMRRWithObjCWeak(Context)) {
      // It is safe to assign a weak reference into a strong variable.
      // Although this code can still have problems:
      //   id x = self.weakProp;
      //   id y = self.weakProp;
      // we do not warn to warn spuriously when 'x' and 'y' are on separate
      // paths through the function. This should be revisited if
      // -Wrepeated-use-of-weak is made flow-sensitive.
      // For ObjCWeak only, we do not warn if the assign is to a non-weak
      // variable, which will be valid for the current autorelease scope.
      if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
                           RHS.get()->getBeginLoc()))
        getCurFunction()->markSafeWeakUse(RHS.get());

    } else if (getLangOpts().ObjCAutoRefCount || getLangOpts().ObjCWeak) {
      checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get());
    }
  }
} else {
  // Compound assignment "x += y"
  ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType);
}

if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
                             RHS.get(), AA_Assigning))
  return QualType();

CheckForNullPointerDereference(*this, LHSExpr);

if (getLangOpts().CPlusPlus20 && LHSType.isVolatileQualified()) {
  if (CompoundType.isNull()) {
    // C++2a [expr.ass]p5:
    //   A simple-assignment whose left operand is of a volatile-qualified
    //   type is deprecated unless the assignment is either a discarded-value
    //   expression or an unevaluated operand
    ExprEvalContexts.back().VolatileAssignmentLHSs.push_back(LHSExpr);
  }
}

// C11 6.5.16p3: The type of an assignment expression is the type of the
// left operand would have after lvalue conversion.
// C11 6.3.2.1p2: ...this is called lvalue conversion. If the lvalue has
// qualified type, the value has the unqualified version of the type of the
// lvalue; additionally, if the lvalue has atomic type, the value has the
// non-atomic version of the type of the lvalue.
// C++ 5.17p1: the type of the assignment expression is that of its left
// operand.
return getLangOpts().CPlusPlus ? LHSType : LHSType.getAtomicUnqualifiedType();
14380}

14382// Scenarios to ignore if expression E is:
14383// 1. an explicit cast expression into void
14384// 2. a function call expression that returns void
14385static bool IgnoreCommaOperand(const Expr *E, const ASTContext &Context) {
E = E->IgnoreParens();

if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
  if (CE->getCastKind() == CK_ToVoid) {
    return true;
  }

  // static_cast<void> on a dependent type will not show up as CK_ToVoid.
  if (CE->getCastKind() == CK_Dependent && E->getType()->isVoidType() &&
      CE->getSubExpr()->getType()->isDependentType()) {
    return true;
  }
}

if (const auto *CE = dyn_cast<CallExpr>(E))
  return CE->getCallReturnType(Context)->isVoidType();
return false;
14403}

14405// Look for instances where it is likely the comma operator is confused with
14406// another operator.  There is an explicit list of acceptable expressions for
14407// the left hand side of the comma operator, otherwise emit a warning.
14408void Sema::DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc) {
// No warnings in macros
if (Loc.isMacroID())
  return;

// Don't warn in template instantiations.
if (inTemplateInstantiation())
  return;

// Scope isn't fine-grained enough to explicitly list the specific cases, so
// instead, skip more than needed, then call back into here with the
// CommaVisitor in SemaStmt.cpp.
// The listed locations are the initialization and increment portions
// of a for loop.  The additional checks are on the condition of
// if statements, do/while loops, and for loops.
// Differences in scope flags for C89 mode requires the extra logic.
const unsigned ForIncrementFlags =
    getLangOpts().C99 || getLangOpts().CPlusPlus
        ? Scope::ControlScope | Scope::ContinueScope | Scope::BreakScope
        : Scope::ContinueScope | Scope::BreakScope;
const unsigned ForInitFlags = Scope::ControlScope | Scope::DeclScope;
const unsigned ScopeFlags = getCurScope()->getFlags();
if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
    (ScopeFlags & ForInitFlags) == ForInitFlags)
  return;

// If there are multiple comma operators used together, get the RHS of the
// of the comma operator as the LHS.
while (const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
  if (BO->getOpcode() != BO_Comma)
    break;
  LHS = BO->getRHS();
}

// Only allow some expressions on LHS to not warn.
if (IgnoreCommaOperand(LHS, Context))
  return;

Diag(Loc, diag::warn_comma_operator);
Diag(LHS->getBeginLoc(), diag::note_cast_to_void)
    << LHS->getSourceRange()
    << FixItHint::CreateInsertion(LHS->getBeginLoc(),
                                  LangOpts.CPlusPlus ? "static_cast<void>("
                                                     : "(void)(")
    << FixItHint::CreateInsertion(PP.getLocForEndOfToken(LHS->getEndLoc()),
                                  ")");
14454}

14456// C99 6.5.17
14457static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS,
                                 SourceLocation Loc) {
LHS = S.CheckPlaceholderExpr(LHS.get());
RHS = S.CheckPlaceholderExpr(RHS.get());
if (LHS.isInvalid() || RHS.isInvalid())
  return QualType();

// C's comma performs lvalue conversion (C99 6.3.2.1) on both its
// operands, but not unary promotions.
// C++'s comma does not do any conversions at all (C++ [expr.comma]p1).

// So we treat the LHS as a ignored value, and in C++ we allow the
// containing site to determine what should be done with the RHS.
LHS = S.IgnoredValueConversions(LHS.get());
if (LHS.isInvalid())
  return QualType();

S.DiagnoseUnusedExprResult(LHS.get(), diag::warn_unused_comma_left_operand);

if (!S.getLangOpts().CPlusPlus) {
  RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get());
  if (RHS.isInvalid())
    return QualType();
  if (!RHS.get()->getType()->isVoidType())
    S.RequireCompleteType(Loc, RHS.get()->getType(),
                          diag::err_incomplete_type);
}

if (!S.getDiagnostics().isIgnored(diag::warn_comma_operator, Loc))
  S.DiagnoseCommaOperator(LHS.get(), Loc);

return RHS.get()->getType();
14489}

14491/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
14492/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
14493static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
                                             ExprValueKind &VK,
                                             ExprObjectKind &OK,
                                             SourceLocation OpLoc,
                                             bool IsInc, bool IsPrefix) {
if (Op->isTypeDependent())
  return S.Context.DependentTy;

QualType ResType = Op->getType();
// Atomic types can be used for increment / decrement where the non-atomic
// versions can, so ignore the _Atomic() specifier for the purpose of
// checking.
if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
  ResType = ResAtomicType->getValueType();

assert(!ResType.isNull() && "no type for increment/decrement expression")(static_cast <bool> (!ResType.isNull() && "no type for increment/decrement expression"
) ? void (0) : __assert_fail ("!ResType.isNull() && \"no type for increment/decrement expression\""
, "clang/lib/Sema/SemaExpr.cpp", 14508, __extension__ __PRETTY_FUNCTION__
));

if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) {
  // Decrement of bool is not allowed.
  if (!IsInc) {
    S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
    return QualType();
  }
  // Increment of bool sets it to true, but is deprecated.
  S.Diag(OpLoc, S.getLangOpts().CPlusPlus17 ? diag::ext_increment_bool
                                            : diag::warn_increment_bool)
    << Op->getSourceRange();
} else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {
  // Error on enum increments and decrements in C++ mode
  S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
  return QualType();
} else if (ResType->isRealType()) {
  // OK!
} else if (ResType->isPointerType()) {
  // C99 6.5.2.4p2, 6.5.6p2
  if (!checkArithmeticOpPointerOperand(S, OpLoc, Op))
    return QualType();
} else if (ResType->isObjCObjectPointerType()) {
  // On modern runtimes, ObjC pointer arithmetic is forbidden.
  // Otherwise, we just need a complete type.
  if (checkArithmeticIncompletePointerType(S, OpLoc, Op) ||
      checkArithmeticOnObjCPointer(S, OpLoc, Op))
    return QualType();
} else if (ResType->isAnyComplexType()) {
  // C99 does not support ++/-- on complex types, we allow as an extension.
  S.Diag(OpLoc, diag::ext_integer_increment_complex)
    << ResType << Op->getSourceRange();
} else if (ResType->isPlaceholderType()) {
  ExprResult PR = S.CheckPlaceholderExpr(Op);
  if (PR.isInvalid()) return QualType();
  return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc,
                                        IsInc, IsPrefix);
} else if (S.getLangOpts().AltiVec && ResType->isVectorType()) {
  // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 )
} else if (S.getLangOpts().ZVector && ResType->isVectorType() &&
           (ResType->castAs<VectorType>()->getVectorKind() !=
            VectorType::AltiVecBool)) {
  // The z vector extensions allow ++ and -- for non-bool vectors.
} else if(S.getLangOpts().OpenCL && ResType->isVectorType() &&
          ResType->castAs<VectorType>()->getElementType()->isIntegerType()) {
  // OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types.
} else {
  S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
    << ResType << int(IsInc) << Op->getSourceRange();
  return QualType();
}
// At this point, we know we have a real, complex or pointer type.
// Now make sure the operand is a modifiable lvalue.
if (CheckForModifiableLvalue(Op, OpLoc, S))
  return QualType();
if (S.getLangOpts().CPlusPlus20 && ResType.isVolatileQualified()) {
  // C++2a [expr.pre.inc]p1, [expr.post.inc]p1:
  //   An operand with volatile-qualified type is deprecated
  S.Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
      << IsInc << ResType;
}
// In C++, a prefix increment is the same type as the operand. Otherwise
// (in C or with postfix), the increment is the unqualified type of the
// operand.
if (IsPrefix && S.getLangOpts().CPlusPlus) {
  VK = VK_LValue;
  OK = Op->getObjectKind();
  return ResType;
} else {
  VK = VK_PRValue;
  return ResType.getUnqualifiedType();
}
14580}


14583/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
14584/// This routine allows us to typecheck complex/recursive expressions
14585/// where the declaration is needed for type checking. We only need to
14586/// handle cases when the expression references a function designator
14587/// or is an lvalue. Here are some examples:
14588///  - &(x) => x
14589///  - &*****f => f for f a function designator.
14590///  - &s.xx => s
14591///  - &s.zz[1].yy -> s, if zz is an array
14592///  - *(x + 1) -> x, if x is an array
14593///  - &"123"[2] -> 0
14594///  - & __real__ x -> x
14595///
14596/// FIXME: We don't recurse to the RHS of a comma, nor handle pointers to
14597/// members.
14598static ValueDecl *getPrimaryDecl(Expr *E) {
switch (E->getStmtClass()) {
case Stmt::DeclRefExprClass:
  return cast<DeclRefExpr>(E)->getDecl();
case Stmt::MemberExprClass:
  // If this is an arrow operator, the address is an offset from
  // the base's value, so the object the base refers to is
  // irrelevant.
  if (cast<MemberExpr>(E)->isArrow())
    return nullptr;
  // Otherwise, the expression refers to a part of the base
  return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
case Stmt::ArraySubscriptExprClass: {
  // FIXME: This code shouldn't be necessary!  We should catch the implicit
  // promotion of register arrays earlier.
  Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
  if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
    if (ICE->getSubExpr()->getType()->isArrayType())
      return getPrimaryDecl(ICE->getSubExpr());
  }
  return nullptr;
}
case Stmt::UnaryOperatorClass: {
  UnaryOperator *UO = cast<UnaryOperator>(E);

  switch(UO->getOpcode()) {
  case UO_Real:
  case UO_Imag:
  case UO_Extension:
    return getPrimaryDecl(UO->getSubExpr());
  default:
    return nullptr;
  }
}
case Stmt::ParenExprClass:
  return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
case Stmt::ImplicitCastExprClass:
  // If the result of an implicit cast is an l-value, we care about
  // the sub-expression; otherwise, the result here doesn't matter.
  return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
case Stmt::CXXUuidofExprClass:
  return cast<CXXUuidofExpr>(E)->getGuidDecl();
default:
  return nullptr;
}
14643}

14645namespace {
14646enum {
AO_Bit_Field = 0,
AO_Vector_Element = 1,
AO_Property_Expansion = 2,
AO_Register_Variable = 3,
AO_Matrix_Element = 4,
AO_No_Error = 5
14653};
14654}
14655/// Diagnose invalid operand for address of operations.
14656///
14657/// \param Type The type of operand which cannot have its address taken.
14658static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc,
                                       Expr *E, unsigned Type) {
S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
14661}

14663/// CheckAddressOfOperand - The operand of & must be either a function
14664/// designator or an lvalue designating an object. If it is an lvalue, the
14665/// object cannot be declared with storage class register or be a bit field.
14666/// Note: The usual conversions are *not* applied to the operand of the &
14667/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
14668/// In C++, the operand might be an overloaded function name, in which case
14669/// we allow the '&' but retain the overloaded-function type.
14670QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){
  if (PTy->getKind() == BuiltinType::Overload) {
    Expr *E = OrigOp.get()->IgnoreParens();
    if (!isa<OverloadExpr>(E)) {
      assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf)(static_cast <bool> (cast<UnaryOperator>(E)->getOpcode
() == UO_AddrOf) ? void (0) : __assert_fail ("cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf"
, "clang/lib/Sema/SemaExpr.cpp", 14675, __extension__ __PRETTY_FUNCTION__
));
      Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
        << OrigOp.get()->getSourceRange();
      return QualType();
    }

    OverloadExpr *Ovl = cast<OverloadExpr>(E);
    if (isa<UnresolvedMemberExpr>(Ovl))
      if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
        Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
          << OrigOp.get()->getSourceRange();
        return QualType();
      }

    return Context.OverloadTy;
  }

  if (PTy->getKind() == BuiltinType::UnknownAny)
    return Context.UnknownAnyTy;

  if (PTy->getKind() == BuiltinType::BoundMember) {
    Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
      << OrigOp.get()->getSourceRange();
    return QualType();
  }

  OrigOp = CheckPlaceholderExpr(OrigOp.get());
  if (OrigOp.isInvalid()) return QualType();
}

if (OrigOp.get()->isTypeDependent())
  return Context.DependentTy;

assert(!OrigOp.get()->hasPlaceholderType())(static_cast <bool> (!OrigOp.get()->hasPlaceholderType
()) ? void (0) : __assert_fail ("!OrigOp.get()->hasPlaceholderType()"
, "clang/lib/Sema/SemaExpr.cpp", 14708, __extension__ __PRETTY_FUNCTION__
));

// Make sure to ignore parentheses in subsequent checks
Expr *op = OrigOp.get()->IgnoreParens();

// In OpenCL captures for blocks called as lambda functions
// are located in the private address space. Blocks used in
// enqueue_kernel can be located in a different address space
// depending on a vendor implementation. Thus preventing
// taking an address of the capture to avoid invalid AS casts.
if (LangOpts.OpenCL) {
  auto* VarRef = dyn_cast<DeclRefExpr>(op);
  if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
    Diag(op->getExprLoc(), diag::err_opencl_taking_address_capture);
    return QualType();
  }
}

if (getLangOpts().C99) {
  // Implement C99-only parts of addressof rules.
  if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
    if (uOp->getOpcode() == UO_Deref)
      // Per C99 6.5.3.2, the address of a deref always returns a valid result
      // (assuming the deref expression is valid).
      return uOp->getSubExpr()->getType();
  }
  // Technically, there should be a check for array subscript
  // expressions here, but the result of one is always an lvalue anyway.
}
ValueDecl *dcl = getPrimaryDecl(op);

if (auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
  if (!checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
                                         op->getBeginLoc()))
    return QualType();

Expr::LValueClassification lval = op->ClassifyLValue(Context);
unsigned AddressOfError = AO_No_Error;

if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
  bool sfinae = (bool)isSFINAEContext();
  Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary
                                : diag::ext_typecheck_addrof_temporary)
    << op->getType() << op->getSourceRange();
  if (sfinae)
    return QualType();
  // Materialize the temporary as an lvalue so that we can take its address.
  OrigOp = op =
      CreateMaterializeTemporaryExpr(op->getType(), OrigOp.get(), true);
} else if (isa<ObjCSelectorExpr>(op)) {
  return Context.getPointerType(op->getType());
} else if (lval == Expr::LV_MemberFunction) {
  // If it's an instance method, make a member pointer.
  // The expression must have exactly the form &A::foo.

  // If the underlying expression isn't a decl ref, give up.
  if (!isa<DeclRefExpr>(op)) {
    Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
      << OrigOp.get()->getSourceRange();
    return QualType();
  }
  DeclRefExpr *DRE = cast<DeclRefExpr>(op);
  CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());

  // The id-expression was parenthesized.
  if (OrigOp.get() != DRE) {
    Diag(OpLoc, diag::err_parens_pointer_member_function)
      << OrigOp.get()->getSourceRange();

  // The method was named without a qualifier.
  } else if (!DRE->getQualifier()) {
    if (MD->getParent()->getName().empty())
      Diag(OpLoc, diag::err_unqualified_pointer_member_function)
        << op->getSourceRange();
    else {
      SmallString<32> Str;
      StringRef Qual = (MD->getParent()->getName() + "::").toStringRef(Str);
      Diag(OpLoc, diag::err_unqualified_pointer_member_function)
        << op->getSourceRange()
        << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual);
    }
  }

  // Taking the address of a dtor is illegal per C++ [class.dtor]p2.
  if (isa<CXXDestructorDecl>(MD))
    Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange();

  QualType MPTy = Context.getMemberPointerType(
      op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr());
  // Under the MS ABI, lock down the inheritance model now.
  if (Context.getTargetInfo().getCXXABI().isMicrosoft())
    (void)isCompleteType(OpLoc, MPTy);
  return MPTy;
} else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
  // C99 6.5.3.2p1
  // The operand must be either an l-value or a function designator
  if (!op->getType()->isFunctionType()) {
    // Use a special diagnostic for loads from property references.
    if (isa<PseudoObjectExpr>(op)) {
      AddressOfError = AO_Property_Expansion;
    } else {
      Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
        << op->getType() << op->getSourceRange();
      return QualType();
    }
  }
} else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1
  // The operand cannot be a bit-field
  AddressOfError = AO_Bit_Field;
} else if (op->getObjectKind() == OK_VectorComponent) {
  // The operand cannot be an element of a vector
  AddressOfError = AO_Vector_Element;
} else if (op->getObjectKind() == OK_MatrixComponent) {
  // The operand cannot be an element of a matrix.
  AddressOfError = AO_Matrix_Element;
} else if (dcl) { // C99 6.5.3.2p1
  // We have an lvalue with a decl. Make sure the decl is not declared
  // with the register storage-class specifier.
  if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
    // in C++ it is not error to take address of a register
    // variable (c++03 7.1.1P3)
    if (vd->getStorageClass() == SC_Register &&
        !getLangOpts().CPlusPlus) {
      AddressOfError = AO_Register_Variable;
    }
  } else if (isa<MSPropertyDecl>(dcl)) {
    AddressOfError = AO_Property_Expansion;
  } else if (isa<FunctionTemplateDecl>(dcl)) {
    return Context.OverloadTy;
  } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
    // Okay: we can take the address of a field.
    // Could be a pointer to member, though, if there is an explicit
    // scope qualifier for the class.
    if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
      DeclContext *Ctx = dcl->getDeclContext();
      if (Ctx && Ctx->isRecord()) {
        if (dcl->getType()->isReferenceType()) {
          Diag(OpLoc,
               diag::err_cannot_form_pointer_to_member_of_reference_type)
            << dcl->getDeclName() << dcl->getType();
          return QualType();
        }

        while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
          Ctx = Ctx->getParent();

        QualType MPTy = Context.getMemberPointerType(
            op->getType(),
            Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
        // Under the MS ABI, lock down the inheritance model now.
        if (Context.getTargetInfo().getCXXABI().isMicrosoft())
          (void)isCompleteType(OpLoc, MPTy);
        return MPTy;
      }
    }
  } else if (!isa<FunctionDecl, NonTypeTemplateParmDecl, BindingDecl,
                  MSGuidDecl, UnnamedGlobalConstantDecl>(dcl))
    llvm_unreachable("Unknown/unexpected decl type")::llvm::llvm_unreachable_internal("Unknown/unexpected decl type"
, "clang/lib/Sema/SemaExpr.cpp", 14865);
}

if (AddressOfError != AO_No_Error) {
  diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError);
  return QualType();
}

if (lval == Expr::LV_IncompleteVoidType) {
  // Taking the address of a void variable is technically illegal, but we
  // allow it in cases which are otherwise valid.
  // Example: "extern void x; void* y = &x;".
  Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
}

// If the operand has type "type", the result has type "pointer to type".
if (op->getType()->isObjCObjectType())
  return Context.getObjCObjectPointerType(op->getType());

if (Context.getTargetInfo().getTriple().isWasm() &&
    op->getType()->isWebAssemblyReferenceType()) {
  Diag(OpLoc, diag::err_wasm_ca_reference)
      << 1 << OrigOp.get()->getSourceRange();
  return QualType();
}

CheckAddressOfPackedMember(op);

return Context.getPointerType(op->getType());
14894}

14896static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
if (!DRE)
  return;
const Decl *D = DRE->getDecl();
if (!D)
  return;
const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
if (!Param)
  return;
if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
  if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
    return;
if (FunctionScopeInfo *FD = S.getCurFunction())
  FD->ModifiedNonNullParams.insert(Param);
14911}

14913/// CheckIndirectionOperand - Type check unary indirection (prefix '*').
14914static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
                                      SourceLocation OpLoc,
                                      bool IsAfterAmp = false) {
if (Op->isTypeDependent())
  return S.Context.DependentTy;

ExprResult ConvResult = S.UsualUnaryConversions(Op);
if (ConvResult.isInvalid())
  return QualType();
Op = ConvResult.get();
QualType OpTy = Op->getType();
QualType Result;

if (isa<CXXReinterpretCastExpr>(Op)) {
  QualType OpOrigType = Op->IgnoreParenCasts()->getType();
  S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
                                   Op->getSourceRange());
}

if (const PointerType *PT = OpTy->getAs<PointerType>())
{
  Result = PT->getPointeeType();
}
else if (const ObjCObjectPointerType *OPT =
           OpTy->getAs<ObjCObjectPointerType>())
  Result = OPT->getPointeeType();
else {
  ExprResult PR = S.CheckPlaceholderExpr(Op);
  if (PR.isInvalid()) return QualType();
  if (PR.get() != Op)
    return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
}

if (Result.isNull()) {
  S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
    << OpTy << Op->getSourceRange();
  return QualType();
}

if (Result->isVoidType()) {
  // C++ [expr.unary.op]p1:
  //   [...] the expression to which [the unary * operator] is applied shall
  //   be a pointer to an object type, or a pointer to a function type
  LangOptions LO = S.getLangOpts();
  if (LO.CPlusPlus)
    S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer_cpp)
        << OpTy << Op->getSourceRange();
  else if (!(LO.C99 && IsAfterAmp) && !S.isUnevaluatedContext())
    S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
        << OpTy << Op->getSourceRange();
}

// Dereferences are usually l-values...
VK = VK_LValue;

// ...except that certain expressions are never l-values in C.
if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType())
  VK = VK_PRValue;

return Result;
14974}

14976BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) {
BinaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown binop!")::llvm::llvm_unreachable_internal("Unknown binop!", "clang/lib/Sema/SemaExpr.cpp"
, 14979);
case tok::periodstar:           Opc = BO_PtrMemD; break;
case tok::arrowstar:            Opc = BO_PtrMemI; break;
case tok::star:                 Opc = BO_Mul; break;
case tok::slash:                Opc = BO_Div; break;
case tok::percent:              Opc = BO_Rem; break;
case tok::plus:                 Opc = BO_Add; break;
case tok::minus:                Opc = BO_Sub; break;
case tok::lessless:             Opc = BO_Shl; break;
case tok::greatergreater:       Opc = BO_Shr; break;
case tok::lessequal:            Opc = BO_LE; break;
case tok::less:                 Opc = BO_LT; break;
case tok::greaterequal:         Opc = BO_GE; break;
case tok::greater:              Opc = BO_GT; break;
case tok::exclaimequal:         Opc = BO_NE; break;
case tok::equalequal:           Opc = BO_EQ; break;
case tok::spaceship:            Opc = BO_Cmp; break;
case tok::amp:                  Opc = BO_And; break;
case tok::caret:                Opc = BO_Xor; break;
case tok::pipe:                 Opc = BO_Or; break;
case tok::ampamp:               Opc = BO_LAnd; break;
case tok::pipepipe:             Opc = BO_LOr; break;
case tok::equal:                Opc = BO_Assign; break;
case tok::starequal:            Opc = BO_MulAssign; break;
case tok::slashequal:           Opc = BO_DivAssign; break;
case tok::percentequal:         Opc = BO_RemAssign; break;
case tok::plusequal:            Opc = BO_AddAssign; break;
case tok::minusequal:           Opc = BO_SubAssign; break;
case tok::lesslessequal:        Opc = BO_ShlAssign; break;
case tok::greatergreaterequal:  Opc = BO_ShrAssign; break;
case tok::ampequal:             Opc = BO_AndAssign; break;
case tok::caretequal:           Opc = BO_XorAssign; break;
case tok::pipeequal:            Opc = BO_OrAssign; break;
case tok::comma:                Opc = BO_Comma; break;
}
return Opc;
15015}

15017static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
tok::TokenKind Kind) {
UnaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown unary op!")::llvm::llvm_unreachable_internal("Unknown unary op!", "clang/lib/Sema/SemaExpr.cpp"
, 15021);
case tok::plusplus:     Opc = UO_PreInc; break;
case tok::minusminus:   Opc = UO_PreDec; break;
case tok::amp:          Opc = UO_AddrOf; break;
case tok::star:         Opc = UO_Deref; break;
case tok::plus:         Opc = UO_Plus; break;
case tok::minus:        Opc = UO_Minus; break;
case tok::tilde:        Opc = UO_Not; break;
case tok::exclaim:      Opc = UO_LNot; break;
case tok::kw___real:    Opc = UO_Real; break;
case tok::kw___imag:    Opc = UO_Imag; break;
case tok::kw___extension__: Opc = UO_Extension; break;
}
return Opc;
15035}

15037const FieldDecl *
15038Sema::getSelfAssignmentClassMemberCandidate(const ValueDecl *SelfAssigned) {
// Explore the case for adding 'this->' to the LHS of a self assignment, very
// common for setters.
// struct A {
// int X;
// -void setX(int X) { X = X; }
// +void setX(int X) { this->X = X; }
// };

// Only consider parameters for self assignment fixes.
if (!isa<ParmVarDecl>(SelfAssigned))
  return nullptr;
const auto *Method =
    dyn_cast_or_null<CXXMethodDecl>(getCurFunctionDecl(true));
if (!Method)
  return nullptr;

const CXXRecordDecl *Parent = Method->getParent();
// In theory this is fixable if the lambda explicitly captures this, but
// that's added complexity that's rarely going to be used.
if (Parent->isLambda())
  return nullptr;

// FIXME: Use an actual Lookup operation instead of just traversing fields
// in order to get base class fields.
auto Field =
    llvm::find_if(Parent->fields(),
                  [Name(SelfAssigned->getDeclName())](const FieldDecl *F) {
                    return F->getDeclName() == Name;
                  });
return (Field != Parent->field_end()) ? *Field : nullptr;
15069}

15071/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
15072/// This warning suppressed in the event of macro expansions.
15073static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
                                 SourceLocation OpLoc, bool IsBuiltin) {
if (S.inTemplateInstantiation())
  return;
if (S.isUnevaluatedContext())
  return;
if (OpLoc.isInvalid() || OpLoc.isMacroID())
  return;
LHSExpr = LHSExpr->IgnoreParenImpCasts();
RHSExpr = RHSExpr->IgnoreParenImpCasts();
const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
if (!LHSDeclRef || !RHSDeclRef ||
    LHSDeclRef->getLocation().isMacroID() ||
    RHSDeclRef->getLocation().isMacroID())
  return;
const ValueDecl *LHSDecl =
  cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
const ValueDecl *RHSDecl =
  cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
if (LHSDecl != RHSDecl)
  return;
if (LHSDecl->getType().isVolatileQualified())
  return;
if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
  if (RefTy->getPointeeType().isVolatileQualified())
    return;

auto Diag = S.Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
                                    : diag::warn_self_assignment_overloaded)
            << LHSDeclRef->getType() << LHSExpr->getSourceRange()
            << RHSExpr->getSourceRange();
if (const FieldDecl *SelfAssignField =
        S.getSelfAssignmentClassMemberCandidate(RHSDecl))
  Diag << 1 << SelfAssignField
       << FixItHint::CreateInsertion(LHSDeclRef->getBeginLoc(), "this->");
else
  Diag << 0;
15111}

15113/// Check if a bitwise-& is performed on an Objective-C pointer.  This
15114/// is usually indicative of introspection within the Objective-C pointer.
15115static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
                                        SourceLocation OpLoc) {
if (!S.getLangOpts().ObjC)
  return;

const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr;
const Expr *LHS = L.get();
const Expr *RHS = R.get();

if (LHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
  ObjCPointerExpr = LHS;
  OtherExpr = RHS;
}
else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
  ObjCPointerExpr = RHS;
  OtherExpr = LHS;
}

// This warning is deliberately made very specific to reduce false
// positives with logic that uses '&' for hashing.  This logic mainly
// looks for code trying to introspect into tagged pointers, which
// code should generally never do.
if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
  unsigned Diag = diag::warn_objc_pointer_masking;
  // Determine if we are introspecting the result of performSelectorXXX.
  const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts();
  // Special case messages to -performSelector and friends, which
  // can return non-pointer values boxed in a pointer value.
  // Some clients may wish to silence warnings in this subcase.
  if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) {
    Selector S = ME->getSelector();
    StringRef SelArg0 = S.getNameForSlot(0);
    if (SelArg0.startswith("performSelector"))
      Diag = diag::warn_objc_pointer_masking_performSelector;
  }

  S.Diag(OpLoc, Diag)
    << ObjCPointerExpr->getSourceRange();
}
15154}

15156static NamedDecl *getDeclFromExpr(Expr *E) {
if (!E)
  return nullptr;
if (auto *DRE = dyn_cast<DeclRefExpr>(E))
  return DRE->getDecl();
if (auto *ME = dyn_cast<MemberExpr>(E))
  return ME->getMemberDecl();
if (auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
  return IRE->getDecl();
return nullptr;
15166}

15168// This helper function promotes a binary operator's operands (which are of a
15169// half vector type) to a vector of floats and then truncates the result to
15170// a vector of either half or short.
15171static ExprResult convertHalfVecBinOp(Sema &S, ExprResult LHS, ExprResult RHS,
                                    BinaryOperatorKind Opc, QualType ResultTy,
                                    ExprValueKind VK, ExprObjectKind OK,
                                    bool IsCompAssign, SourceLocation OpLoc,
                                    FPOptionsOverride FPFeatures) {
auto &Context = S.getASTContext();
assert((isVector(ResultTy, Context.HalfTy) ||(static_cast <bool> ((isVector(ResultTy, Context.HalfTy
) || isVector(ResultTy, Context.ShortTy)) && "Result must be a vector of half or short"
) ? void (0) : __assert_fail ("(isVector(ResultTy, Context.HalfTy) || isVector(ResultTy, Context.ShortTy)) && \"Result must be a vector of half or short\""
, "clang/lib/Sema/SemaExpr.cpp", 15179, __extension__ __PRETTY_FUNCTION__
))
        isVector(ResultTy, Context.ShortTy)) &&(static_cast <bool> ((isVector(ResultTy, Context.HalfTy
) || isVector(ResultTy, Context.ShortTy)) && "Result must be a vector of half or short"
) ? void (0) : __assert_fail ("(isVector(ResultTy, Context.HalfTy) || isVector(ResultTy, Context.ShortTy)) && \"Result must be a vector of half or short\""
, "clang/lib/Sema/SemaExpr.cpp", 15179, __extension__ __PRETTY_FUNCTION__
))
       "Result must be a vector of half or short")(static_cast <bool> ((isVector(ResultTy, Context.HalfTy
) || isVector(ResultTy, Context.ShortTy)) && "Result must be a vector of half or short"
) ? void (0) : __assert_fail ("(isVector(ResultTy, Context.HalfTy) || isVector(ResultTy, Context.ShortTy)) && \"Result must be a vector of half or short\""
, "clang/lib/Sema/SemaExpr.cpp", 15179, __extension__ __PRETTY_FUNCTION__
));
assert(isVector(LHS.get()->getType(), Context.HalfTy) &&(static_cast <bool> (isVector(LHS.get()->getType(), Context
.HalfTy) && isVector(RHS.get()->getType(), Context
.HalfTy) && "both operands expected to be a half vector"
) ? void (0) : __assert_fail ("isVector(LHS.get()->getType(), Context.HalfTy) && isVector(RHS.get()->getType(), Context.HalfTy) && \"both operands expected to be a half vector\""
, "clang/lib/Sema/SemaExpr.cpp", 15182, __extension__ __PRETTY_FUNCTION__
))
       isVector(RHS.get()->getType(), Context.HalfTy) &&(static_cast <bool> (isVector(LHS.get()->getType(), Context
.HalfTy) && isVector(RHS.get()->getType(), Context
.HalfTy) && "both operands expected to be a half vector"
) ? void (0) : __assert_fail ("isVector(LHS.get()->getType(), Context.HalfTy) && isVector(RHS.get()->getType(), Context.HalfTy) && \"both operands expected to be a half vector\""
, "clang/lib/Sema/SemaExpr.cpp", 15182, __extension__ __PRETTY_FUNCTION__
))
       "both operands expected to be a half vector")(static_cast <bool> (isVector(LHS.get()->getType(), Context
.HalfTy) && isVector(RHS.get()->getType(), Context
.HalfTy) && "both operands expected to be a half vector"
) ? void (0) : __assert_fail ("isVector(LHS.get()->getType(), Context.HalfTy) && isVector(RHS.get()->getType(), Context.HalfTy) && \"both operands expected to be a half vector\""
, "clang/lib/Sema/SemaExpr.cpp", 15182, __extension__ __PRETTY_FUNCTION__
));

RHS = convertVector(RHS.get(), Context.FloatTy, S);
QualType BinOpResTy = RHS.get()->getType();

// If Opc is a comparison, ResultType is a vector of shorts. In that case,
// change BinOpResTy to a vector of ints.
if (isVector(ResultTy, Context.ShortTy))
  BinOpResTy = S.GetSignedVectorType(BinOpResTy);

if (IsCompAssign)
  return CompoundAssignOperator::Create(Context, LHS.get(), RHS.get(), Opc,
                                        ResultTy, VK, OK, OpLoc, FPFeatures,
                                        BinOpResTy, BinOpResTy);

LHS = convertVector(LHS.get(), Context.FloatTy, S);
auto *BO = BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc,
                                  BinOpResTy, VK, OK, OpLoc, FPFeatures);
return convertVector(BO, ResultTy->castAs<VectorType>()->getElementType(), S);
15201}

15203static std::pair<ExprResult, ExprResult>
15204CorrectDelayedTyposInBinOp(Sema &S, BinaryOperatorKind Opc, Expr *LHSExpr,
                         Expr *RHSExpr) {
ExprResult LHS = LHSExpr, RHS = RHSExpr;
if (!S.Context.isDependenceAllowed()) {
  // C cannot handle TypoExpr nodes on either side of a binop because it
  // doesn't handle dependent types properly, so make sure any TypoExprs have
  // been dealt with before checking the operands.
  LHS = S.CorrectDelayedTyposInExpr(LHS);
  RHS = S.CorrectDelayedTyposInExpr(
      RHS, /*InitDecl=*/nullptr, /*RecoverUncorrectedTypos=*/false,
      [Opc, LHS](Expr *E) {
        if (Opc != BO_Assign)
          return ExprResult(E);
        // Avoid correcting the RHS to the same Expr as the LHS.
        Decl *D = getDeclFromExpr(E);
        return (D && D == getDeclFromExpr(LHS.get())) ? ExprError() : E;
      });
}
return std::make_pair(LHS, RHS);
15223}

15225/// Returns true if conversion between vectors of halfs and vectors of floats
15226/// is needed.
15227static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx,
                                   Expr *E0, Expr *E1 = nullptr) {
if (!OpRequiresConversion || Ctx.getLangOpts().NativeHalfType ||
    Ctx.getTargetInfo().useFP16ConversionIntrinsics())
  return false;

auto HasVectorOfHalfType = [&Ctx](Expr *E) {
  QualType Ty = E->IgnoreImplicit()->getType();

  // Don't promote half precision neon vectors like float16x4_t in arm_neon.h
  // to vectors of floats. Although the element type of the vectors is __fp16,
  // the vectors shouldn't be treated as storage-only types. See the
  // discussion here: https://reviews.llvm.org/rG825235c140e7
  if (const VectorType *VT = Ty->getAs<VectorType>()) {
    if (VT->getVectorKind() == VectorType::NeonVector)
      return false;
    return VT->getElementType().getCanonicalType() == Ctx.HalfTy;
  }
  return false;
};

return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
15249}

15251/// CreateBuiltinBinOp - Creates a new built-in binary operation with
15252/// operator @p Opc at location @c TokLoc. This routine only supports
15253/// built-in operations; ActOnBinOp handles overloaded operators.
15254ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
                                  BinaryOperatorKind Opc,
                                  Expr *LHSExpr, Expr *RHSExpr) {
if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) {
  // The syntax only allows initializer lists on the RHS of assignment,
  // so we don't need to worry about accepting invalid code for
  // non-assignment operators.
  // C++11 5.17p9:
  //   The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning
  //   of x = {} is x = T().
  InitializationKind Kind = InitializationKind::CreateDirectList(
      RHSExpr->getBeginLoc(), RHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
  InitializedEntity Entity =
      InitializedEntity::InitializeTemporary(LHSExpr->getType());
  InitializationSequence InitSeq(*this, Entity, Kind, RHSExpr);
  ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr);
  if (Init.isInvalid())
    return Init;
  RHSExpr = Init.get();
}

ExprResult LHS = LHSExpr, RHS = RHSExpr;
QualType ResultTy;     // Result type of the binary operator.
// The following two variables are used for compound assignment operators
QualType CompLHSTy;    // Type of LHS after promotions for computation
QualType CompResultTy; // Type of computation result
ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
bool ConvertHalfVec = false;

std::tie(LHS, RHS) = CorrectDelayedTyposInBinOp(*this, Opc, LHSExpr, RHSExpr);
if (!LHS.isUsable() || !RHS.isUsable())
  return ExprError();

if (getLangOpts().OpenCL) {
  QualType LHSTy = LHSExpr->getType();
  QualType RHSTy = RHSExpr->getType();
  // OpenCLC v2.0 s6.13.11.1 allows atomic variables to be initialized by
  // the ATOMIC_VAR_INIT macro.
  if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
    SourceRange SR(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
    if (BO_Assign == Opc)
      Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
    else
      ResultTy = InvalidOperands(OpLoc, LHS, RHS);
    return ExprError();
  }

  // OpenCL special types - image, sampler, pipe, and blocks are to be used
  // only with a builtin functions and therefore should be disallowed here.
  if (LHSTy->isImageType() || RHSTy->isImageType() ||
      LHSTy->isSamplerT() || RHSTy->isSamplerT() ||
      LHSTy->isPipeType() || RHSTy->isPipeType() ||
      LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
    ResultTy = InvalidOperands(OpLoc, LHS, RHS);
    return ExprError();
  }
}

checkTypeSupport(LHSExpr->getType(), OpLoc, /*ValueDecl*/ nullptr);
checkTypeSupport(RHSExpr->getType(), OpLoc, /*ValueDecl*/ nullptr);

switch (Opc) {
case BO_Assign:
  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType(), Opc);
  if (getLangOpts().CPlusPlus &&
      LHS.get()->getObjectKind() != OK_ObjCProperty) {
    VK = LHS.get()->getValueKind();
    OK = LHS.get()->getObjectKind();
  }
  if (!ResultTy.isNull()) {
    DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
    DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc);

    // Avoid copying a block to the heap if the block is assigned to a local
    // auto variable that is declared in the same scope as the block. This
    // optimization is unsafe if the local variable is declared in an outer
    // scope. For example:
    //
    // BlockTy b;
    // {
    //   b = ^{...};
    // }
    // // It is unsafe to invoke the block here if it wasn't copied to the
    // // heap.
    // b();

    if (auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
      if (auto *DRE = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParens()))
        if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
          if (VD->hasLocalStorage() && getCurScope()->isDeclScope(VD))
            BE->getBlockDecl()->setCanAvoidCopyToHeap();

    if (LHS.get()->getType().hasNonTrivialToPrimitiveCopyCUnion())
      checkNonTrivialCUnion(LHS.get()->getType(), LHS.get()->getExprLoc(),
                            NTCUC_Assignment, NTCUK_Copy);
  }
  RecordModifiableNonNullParam(*this, LHS.get());
  break;
case BO_PtrMemD:
case BO_PtrMemI:
  ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
                                          Opc == BO_PtrMemI);
  break;
case BO_Mul:
case BO_Div:
  ConvertHalfVec = true;
  ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false,
                                         Opc == BO_Div);
  break;
case BO_Rem:
  ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc);
  break;
case BO_Add:
  ConvertHalfVec = true;
  ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc);
  break;
case BO_Sub:
  ConvertHalfVec = true;
  ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc);
  break;
case BO_Shl:
case BO_Shr:
  ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc);
  break;
case BO_LE:
case BO_LT:
case BO_GE:
case BO_GT:
  ConvertHalfVec = true;
  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
  break;
case BO_EQ:
case BO_NE:
  ConvertHalfVec = true;
  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
  break;
case BO_Cmp:
  ConvertHalfVec = true;
  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
  assert(ResultTy.isNull() || ResultTy->getAsCXXRecordDecl())(static_cast <bool> (ResultTy.isNull() || ResultTy->
getAsCXXRecordDecl()) ? void (0) : __assert_fail ("ResultTy.isNull() || ResultTy->getAsCXXRecordDecl()"
, "clang/lib/Sema/SemaExpr.cpp", 15394, __extension__ __PRETTY_FUNCTION__
));
  break;
case BO_And:
  checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc);
  [[fallthrough]];
case BO_Xor:
case BO_Or:
  ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, Opc);
  break;
case BO_LAnd:
case BO_LOr:
  ConvertHalfVec = true;
  ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc);
  break;
case BO_MulAssign:
case BO_DivAssign:
  ConvertHalfVec = true;
  CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true,
                                             Opc == BO_DivAssign);
  CompLHSTy = CompResultTy;
  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
    ResultTy =
        CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy, Opc);
  break;
case BO_RemAssign:
  CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true);
  CompLHSTy = CompResultTy;
  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
    ResultTy =
        CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy, Opc);
  break;
case BO_AddAssign:
  ConvertHalfVec = true;
  CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy);
  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
    ResultTy =
        CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy, Opc);
  break;
case BO_SubAssign:
  ConvertHalfVec = true;
  CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy);
  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
    ResultTy =
        CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy, Opc);
  break;
case BO_ShlAssign:
case BO_ShrAssign:
  CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true);
  CompLHSTy = CompResultTy;
  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
    ResultTy =
        CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy, Opc);
  break;
case BO_AndAssign:
case BO_OrAssign: // fallthrough
  DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
  [[fallthrough]];
case BO_XorAssign:
  CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, Opc);
  CompLHSTy = CompResultTy;
  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
    ResultTy =
        CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy, Opc);
  break;
case BO_Comma:
  ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc);
  if (getLangOpts().CPlusPlus && !RHS.isInvalid()) {
    VK = RHS.get()->getValueKind();
    OK = RHS.get()->getObjectKind();
  }
  break;
}
if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid())
  return ExprError();

// Some of the binary operations require promoting operands of half vector to
// float vectors and truncating the result back to half vector. For now, we do
// this only when HalfArgsAndReturn is set (that is, when the target is arm or
// arm64).
assert((static_cast <bool> ((Opc == BO_Comma || isVector(RHS.get
()->getType(), Context.HalfTy) == isVector(LHS.get()->getType
(), Context.HalfTy)) && "both sides are half vectors or neither sides are"
) ? void (0) : __assert_fail ("(Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) == isVector(LHS.get()->getType(), Context.HalfTy)) && \"both sides are half vectors or neither sides are\""
, "clang/lib/Sema/SemaExpr.cpp", 15476, __extension__ __PRETTY_FUNCTION__
))
    (Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) ==(static_cast <bool> ((Opc == BO_Comma || isVector(RHS.get
()->getType(), Context.HalfTy) == isVector(LHS.get()->getType
(), Context.HalfTy)) && "both sides are half vectors or neither sides are"
) ? void (0) : __assert_fail ("(Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) == isVector(LHS.get()->getType(), Context.HalfTy)) && \"both sides are half vectors or neither sides are\""
, "clang/lib/Sema/SemaExpr.cpp", 15476, __extension__ __PRETTY_FUNCTION__
))
                            isVector(LHS.get()->getType(), Context.HalfTy)) &&(static_cast <bool> ((Opc == BO_Comma || isVector(RHS.get
()->getType(), Context.HalfTy) == isVector(LHS.get()->getType
(), Context.HalfTy)) && "both sides are half vectors or neither sides are"
) ? void (0) : __assert_fail ("(Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) == isVector(LHS.get()->getType(), Context.HalfTy)) && \"both sides are half vectors or neither sides are\""
, "clang/lib/Sema/SemaExpr.cpp", 15476, __extension__ __PRETTY_FUNCTION__
))
    "both sides are half vectors or neither sides are")(static_cast <bool> ((Opc == BO_Comma || isVector(RHS.get
()->getType(), Context.HalfTy) == isVector(LHS.get()->getType
(), Context.HalfTy)) && "both sides are half vectors or neither sides are"
) ? void (0) : __assert_fail ("(Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) == isVector(LHS.get()->getType(), Context.HalfTy)) && \"both sides are half vectors or neither sides are\""
, "clang/lib/Sema/SemaExpr.cpp", 15476, __extension__ __PRETTY_FUNCTION__
));
ConvertHalfVec =
    needsConversionOfHalfVec(ConvertHalfVec, Context, LHS.get(), RHS.get());

// Check for array bounds violations for both sides of the BinaryOperator
CheckArrayAccess(LHS.get());
CheckArrayAccess(RHS.get());

if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
  NamedDecl *ObjectSetClass = LookupSingleName(TUScope,
                                               &Context.Idents.get("object_setClass"),
                                               SourceLocation(), LookupOrdinaryName);
  if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {
    SourceLocation RHSLocEnd = getLocForEndOfToken(RHS.get()->getEndLoc());
    Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign)
        << FixItHint::CreateInsertion(LHS.get()->getBeginLoc(),
                                      "object_setClass(")
        << FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc),
                                        ",")
        << FixItHint::CreateInsertion(RHSLocEnd, ")");
  }
  else
    Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);
}
else if (const ObjCIvarRefExpr *OIRE =
         dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
  DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());

// Opc is not a compound assignment if CompResultTy is null.
if (CompResultTy.isNull()) {
  if (ConvertHalfVec)
    return convertHalfVecBinOp(*this, LHS, RHS, Opc, ResultTy, VK, OK, false,
                               OpLoc, CurFPFeatureOverrides());
  return BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc, ResultTy,
                                VK, OK, OpLoc, CurFPFeatureOverrides());
}

// Handle compound assignments.
if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
    OK_ObjCProperty) {
  VK = VK_LValue;
  OK = LHS.get()->getObjectKind();
}

// The LHS is not converted to the result type for fixed-point compound
// assignment as the common type is computed on demand. Reset the CompLHSTy
// to the LHS type we would have gotten after unary conversions.
if (CompResultTy->isFixedPointType())
  CompLHSTy = UsualUnaryConversions(LHS.get()).get()->getType();

if (ConvertHalfVec)
  return convertHalfVecBinOp(*this, LHS, RHS, Opc, ResultTy, VK, OK, true,
                             OpLoc, CurFPFeatureOverrides());

return CompoundAssignOperator::Create(
    Context, LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, OpLoc,
    CurFPFeatureOverrides(), CompLHSTy, CompResultTy);
15533}

15535/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
15536/// operators are mixed in a way that suggests that the programmer forgot that
15537/// comparison operators have higher precedence. The most typical example of
15538/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
15539static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc,
                                    SourceLocation OpLoc, Expr *LHSExpr,
                                    Expr *RHSExpr) {
BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr);
BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr);

// Check that one of the sides is a comparison operator and the other isn't.
bool isLeftComp = LHSBO && LHSBO->isComparisonOp();
bool isRightComp = RHSBO && RHSBO->isComparisonOp();
if (isLeftComp == isRightComp)
  return;

// Bitwise operations are sometimes used as eager logical ops.
// Don't diagnose this.
bool isLeftBitwise = LHSBO && LHSBO->isBitwiseOp();
bool isRightBitwise = RHSBO && RHSBO->isBitwiseOp();
if (isLeftBitwise || isRightBitwise)
  return;

SourceRange DiagRange = isLeftComp
                            ? SourceRange(LHSExpr->getBeginLoc(), OpLoc)
                            : SourceRange(OpLoc, RHSExpr->getEndLoc());
StringRef OpStr = isLeftComp ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr();
SourceRange ParensRange =
    isLeftComp
        ? SourceRange(LHSBO->getRHS()->getBeginLoc(), RHSExpr->getEndLoc())
        : SourceRange(LHSExpr->getBeginLoc(), RHSBO->getLHS()->getEndLoc());

Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
  << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
SuggestParentheses(Self, OpLoc,
  Self.PDiag(diag::note_precedence_silence) << OpStr,
  (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
SuggestParentheses(Self, OpLoc,
  Self.PDiag(diag::note_precedence_bitwise_first)
    << BinaryOperator::getOpcodeStr(Opc),
  ParensRange);
15576}

15578/// It accepts a '&&' expr that is inside a '||' one.
15579/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
15580/// in parentheses.
15581static void
15582EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
                                     BinaryOperator *Bop) {
assert(Bop->getOpcode() == BO_LAnd)(static_cast <bool> (Bop->getOpcode() == BO_LAnd) ? void
 (0) : __assert_fail ("Bop->getOpcode() == BO_LAnd", "clang/lib/Sema/SemaExpr.cpp"
, 15584, __extension__ __PRETTY_FUNCTION__));
Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)
    << Bop->getSourceRange() << OpLoc;
SuggestParentheses(Self, Bop->getOperatorLoc(),
  Self.PDiag(diag::note_precedence_silence)
    << Bop->getOpcodeStr(),
  Bop->getSourceRange());
15591}

15593/// Look for '&&' in the left hand of a '||' expr.
15594static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc,
                                           Expr *LHSExpr, Expr *RHSExpr) {
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) {
  if (Bop->getOpcode() == BO_LAnd) {
    // If it's "string_literal && a || b" don't warn since the precedence
    // doesn't matter.
    if (!isa<StringLiteral>(Bop->getLHS()->IgnoreParenImpCasts()))
      return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
  } else if (Bop->getOpcode() == BO_LOr) {
    if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
      // If it's "a || b && string_literal || c" we didn't warn earlier for
      // "a || b && string_literal", but warn now.
      if (RBop->getOpcode() == BO_LAnd &&
          isa<StringLiteral>(RBop->getRHS()->IgnoreParenImpCasts()))
        return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop);
    }
  }
}
15612}

15614/// Look for '&&' in the right hand of a '||' expr.
15615static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc,
                                           Expr *LHSExpr, Expr *RHSExpr) {
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) {
  if (Bop->getOpcode() == BO_LAnd) {
    // If it's "a || b && string_literal" don't warn since the precedence
    // doesn't matter.
    if (!isa<StringLiteral>(Bop->getRHS()->IgnoreParenImpCasts()))
      return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
  }
}
15625}

15627/// Look for bitwise op in the left or right hand of a bitwise op with
15628/// lower precedence and emit a diagnostic together with a fixit hint that wraps
15629/// the '&' expression in parentheses.
15630static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc,
                                       SourceLocation OpLoc, Expr *SubExpr) {
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
  if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
    S.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
      << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc)
      << Bop->getSourceRange() << OpLoc;
    SuggestParentheses(S, Bop->getOperatorLoc(),
      S.PDiag(diag::note_precedence_silence)
        << Bop->getOpcodeStr(),
      Bop->getSourceRange());
  }
}
15643}

15645static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc,
                                  Expr *SubExpr, StringRef Shift) {
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
  if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
    StringRef Op = Bop->getOpcodeStr();
    S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
        << Bop->getSourceRange() << OpLoc << Shift << Op;
    SuggestParentheses(S, Bop->getOperatorLoc(),
        S.PDiag(diag::note_precedence_silence) << Op,
        Bop->getSourceRange());
  }
}
15657}

15659static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc,
                               Expr *LHSExpr, Expr *RHSExpr) {
CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr);
if (!OCE)
  return;

FunctionDecl *FD = OCE->getDirectCallee();
if (!FD || !FD->isOverloadedOperator())
  return;

OverloadedOperatorKind Kind = FD->getOverloadedOperator();
if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
  return;

S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
    << LHSExpr->getSourceRange() << RHSExpr->getSourceRange()
    << (Kind == OO_LessLess);
SuggestParentheses(S, OCE->getOperatorLoc(),
                   S.PDiag(diag::note_precedence_silence)
                       << (Kind == OO_LessLess ? "<<" : ">>"),
                   OCE->getSourceRange());
SuggestParentheses(
    S, OpLoc, S.PDiag(diag::note_evaluate_comparison_first),
    SourceRange(OCE->getArg(1)->getBeginLoc(), RHSExpr->getEndLoc()));
15683}

15685/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
15686/// precedence.
15687static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
                                  SourceLocation OpLoc, Expr *LHSExpr,
                                  Expr *RHSExpr){
// Diagnose "arg1 'bitwise' arg2 'eq' arg3".
if (BinaryOperator::isBitwiseOp(Opc))
  DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr);

// Diagnose "arg1 & arg2 | arg3"
if ((Opc == BO_Or || Opc == BO_Xor) &&
    !OpLoc.isMacroID()/* Don't warn in macros. */) {
  DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, LHSExpr);
  DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, RHSExpr);
}

// Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
// We don't warn for 'assert(a || b && "bad")' since this is safe.
if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
  DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr);
  DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr);
}

if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
    || Opc == BO_Shr) {
  StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
  DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
  DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
}

// Warn on overloaded shift operators and comparisons, such as:
// cout << 5 == 4;
if (BinaryOperator::isComparisonOp(Opc))
  DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr);
15719}

15721// Binary Operators.  'Tok' is the token for the operator.
15722ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
                          tok::TokenKind Kind,
                          Expr *LHSExpr, Expr *RHSExpr) {
BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
assert(LHSExpr && "ActOnBinOp(): missing left expression")(static_cast <bool> (LHSExpr && "ActOnBinOp(): missing left expression"
) ? void (0) : __assert_fail ("LHSExpr && \"ActOnBinOp(): missing left expression\""
, "clang/lib/Sema/SemaExpr.cpp", 15726, __extension__ __PRETTY_FUNCTION__
));
assert(RHSExpr && "ActOnBinOp(): missing right expression")(static_cast <bool> (RHSExpr && "ActOnBinOp(): missing right expression"
) ? void (0) : __assert_fail ("RHSExpr && \"ActOnBinOp(): missing right expression\""
, "clang/lib/Sema/SemaExpr.cpp", 15727, __extension__ __PRETTY_FUNCTION__
));

// Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);

return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
15733}

15735void Sema::LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
                     UnresolvedSetImpl &Functions) {
OverloadedOperatorKind OverOp = BinaryOperator::getOverloadedOperator(Opc);
if (OverOp != OO_None && OverOp != OO_Equal)
  LookupOverloadedOperatorName(OverOp, S, Functions);

// In C++20 onwards, we may have a second operator to look up.
if (getLangOpts().CPlusPlus20) {
  if (OverloadedOperatorKind ExtraOp = getRewrittenOverloadedOperator(OverOp))
    LookupOverloadedOperatorName(ExtraOp, S, Functions);
}
15746}

15748/// Build an overloaded binary operator expression in the given scope.
15749static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
                                     BinaryOperatorKind Opc,
                                     Expr *LHS, Expr *RHS) {
switch (Opc) {
case BO_Assign:
  // In the non-overloaded case, we warn about self-assignment (x = x) for
  // both simple assignment and certain compound assignments where algebra
  // tells us the operation yields a constant result.  When the operator is
  // overloaded, we can't do the latter because we don't want to assume that
  // those algebraic identities still apply; for example, a path-building
  // library might use operator/= to append paths.  But it's still reasonable
  // to assume that simple assignment is just moving/copying values around
  // and so self-assignment is likely a bug.
  DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
  [[fallthrough]];
case BO_DivAssign:
case BO_RemAssign:
case BO_SubAssign:
case BO_AndAssign:
case BO_OrAssign:
case BO_XorAssign:
  CheckIdentityFieldAssignment(LHS, RHS, OpLoc, S);
  break;
default:
  break;
}

// Find all of the overloaded operators visible from this point.
UnresolvedSet<16> Functions;
S.LookupBinOp(Sc, OpLoc, Opc, Functions);

// Build the (potentially-overloaded, potentially-dependent)
// binary operation.
return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
15783}

15785ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
                          BinaryOperatorKind Opc,
                          Expr *LHSExpr, Expr *RHSExpr) {
ExprResult LHS, RHS;
std::tie(LHS, RHS) = CorrectDelayedTyposInBinOp(*this, Opc, LHSExpr, RHSExpr);
if (!LHS.isUsable() || !RHS.isUsable())
  return ExprError();
LHSExpr = LHS.get();
RHSExpr = RHS.get();

// We want to end up calling one of checkPseudoObjectAssignment
// (if the LHS is a pseudo-object), BuildOverloadedBinOp (if
// both expressions are overloadable or either is type-dependent),
// or CreateBuiltinBinOp (in any other case).  We also want to get
// any placeholder types out of the way.

// Handle pseudo-objects in the LHS.
if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) {
  // Assignments with a pseudo-object l-value need special analysis.
  if (pty->getKind() == BuiltinType::PseudoObject &&
      BinaryOperator::isAssignmentOp(Opc))
    return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr);

  // Don't resolve overloads if the other type is overloadable.
  if (getLangOpts().CPlusPlus && pty->getKind() == BuiltinType::Overload) {
    // We can't actually test that if we still have a placeholder,
    // though.  Fortunately, none of the exceptions we see in that
    // code below are valid when the LHS is an overload set.  Note
    // that an overload set can be dependently-typed, but it never
    // instantiates to having an overloadable type.
    ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
    if (resolvedRHS.isInvalid()) return ExprError();
    RHSExpr = resolvedRHS.get();

    if (RHSExpr->isTypeDependent() ||
        RHSExpr->getType()->isOverloadableType())
      return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
  }

  // If we're instantiating "a.x < b" or "A::x < b" and 'x' names a function
  // template, diagnose the missing 'template' keyword instead of diagnosing
  // an invalid use of a bound member function.
  //
  // Note that "A::x < b" might be valid if 'b' has an overloadable type due
  // to C++1z [over.over]/1.4, but we already checked for that case above.
  if (Opc == BO_LT && inTemplateInstantiation() &&
      (pty->getKind() == BuiltinType::BoundMember ||
       pty->getKind() == BuiltinType::Overload)) {
    auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
    if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
        llvm::any_of(OE->decls(), [](NamedDecl *ND) {
          return isa<FunctionTemplateDecl>(ND);
        })) {
      Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
                              : OE->getNameLoc(),
           diag::err_template_kw_missing)
        << OE->getName().getAsString() << "";
      return ExprError();
    }
  }

  ExprResult LHS = CheckPlaceholderExpr(LHSExpr);
  if (LHS.isInvalid()) return ExprError();
  LHSExpr = LHS.get();
}

// Handle pseudo-objects in the RHS.
if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) {
  // An overload in the RHS can potentially be resolved by the type
  // being assigned to.
  if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
    if (getLangOpts().CPlusPlus &&
        (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent() ||
         LHSExpr->getType()->isOverloadableType()))
      return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);

    return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
  }

  // Don't resolve overloads if the other type is overloadable.
  if (getLangOpts().CPlusPlus && pty->getKind() == BuiltinType::Overload &&
      LHSExpr->getType()->isOverloadableType())
    return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);

  ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
  if (!resolvedRHS.isUsable()) return ExprError();
  RHSExpr = resolvedRHS.get();
}

if (getLangOpts().CPlusPlus) {
  // If either expression is type-dependent, always build an
  // overloaded op.
  if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
    return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);

  // Otherwise, build an overloaded op if either expression has an
  // overloadable type.
  if (LHSExpr->getType()->isOverloadableType() ||
      RHSExpr->getType()->isOverloadableType())
    return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
}

if (getLangOpts().RecoveryAST &&
    (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())) {
  assert(!getLangOpts().CPlusPlus)(static_cast <bool> (!getLangOpts().CPlusPlus) ? void (
0) : __assert_fail ("!getLangOpts().CPlusPlus", "clang/lib/Sema/SemaExpr.cpp"
, 15889, __extension__ __PRETTY_FUNCTION__));
  assert((LHSExpr->containsErrors() || RHSExpr->containsErrors()) &&(static_cast <bool> ((LHSExpr->containsErrors() || RHSExpr
->containsErrors()) && "Should only occur in error-recovery path."
) ? void (0) : __assert_fail ("(LHSExpr->containsErrors() || RHSExpr->containsErrors()) && \"Should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 15891, __extension__ __PRETTY_FUNCTION__
))
         "Should only occur in error-recovery path.")(static_cast <bool> ((LHSExpr->containsErrors() || RHSExpr
->containsErrors()) && "Should only occur in error-recovery path."
) ? void (0) : __assert_fail ("(LHSExpr->containsErrors() || RHSExpr->containsErrors()) && \"Should only occur in error-recovery path.\""
, "clang/lib/Sema/SemaExpr.cpp", 15891, __extension__ __PRETTY_FUNCTION__
));
  if (BinaryOperator::isCompoundAssignmentOp(Opc))
    // C [6.15.16] p3:
    // An assignment expression has the value of the left operand after the
    // assignment, but is not an lvalue.
    return CompoundAssignOperator::Create(
        Context, LHSExpr, RHSExpr, Opc,
        LHSExpr->getType().getUnqualifiedType(), VK_PRValue, OK_Ordinary,
        OpLoc, CurFPFeatureOverrides());
  QualType ResultType;
  switch (Opc) {
  case BO_Assign:
    ResultType = LHSExpr->getType().getUnqualifiedType();
    break;
  case BO_LT:
  case BO_GT:
  case BO_LE:
  case BO_GE:
  case BO_EQ:
  case BO_NE:
  case BO_LAnd:
  case BO_LOr:
    // These operators have a fixed result type regardless of operands.
    ResultType = Context.IntTy;
    break;
  case BO_Comma:
    ResultType = RHSExpr->getType();
    break;
  default:
    ResultType = Context.DependentTy;
    break;
  }
  return BinaryOperator::Create(Context, LHSExpr, RHSExpr, Opc, ResultType,
                                VK_PRValue, OK_Ordinary, OpLoc,
                                CurFPFeatureOverrides());
}

// Build a built-in binary operation.
return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
15930}

15932static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) {
if (T.isNull() || T->isDependentType())
  return false;

if (!Ctx.isPromotableIntegerType(T))
  return true;

return Ctx.getIntWidth(T) >= Ctx.getIntWidth(Ctx.IntTy);
15940}

15942ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
                                    UnaryOperatorKind Opc, Expr *InputExpr,
                                    bool IsAfterAmp) {
ExprResult Input = InputExpr;
ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType resultType;
bool CanOverflow = false;

bool ConvertHalfVec = false;
if (getLangOpts().OpenCL) {
  QualType Ty = InputExpr->getType();
  // The only legal unary operation for atomics is '&'.
  if ((Opc != UO_AddrOf && Ty->isAtomicType()) ||
  // OpenCL special types - image, sampler, pipe, and blocks are to be used
  // only with a builtin functions and therefore should be disallowed here.
      (Ty->isImageType() || Ty->isSamplerT() || Ty->isPipeType()
      || Ty->isBlockPointerType())) {
    return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                     << InputExpr->getType()
                     << Input.get()->getSourceRange());
  }
}

if (getLangOpts().HLSL && OpLoc.isValid()) {
  if (Opc == UO_AddrOf)
    return ExprError(Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 0);
  if (Opc == UO_Deref)
    return ExprError(Diag(OpLoc, diag::err_hlsl_operator_unsupported) << 1);
}

switch (Opc) {
case UO_PreInc:
case UO_PreDec:
case UO_PostInc:
case UO_PostDec:
  resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OK,
                                              OpLoc,
                                              Opc == UO_PreInc ||
                                              Opc == UO_PostInc,
                                              Opc == UO_PreInc ||
                                              Opc == UO_PreDec);
  CanOverflow = isOverflowingIntegerType(Context, resultType);
  break;
case UO_AddrOf:
  resultType = CheckAddressOfOperand(Input, OpLoc);
  CheckAddressOfNoDeref(InputExpr);
  RecordModifiableNonNullParam(*this, InputExpr);
  break;
case UO_Deref: {
  Input = DefaultFunctionArrayLvalueConversion(Input.get());
  if (Input.isInvalid()) return ExprError();
  resultType =
      CheckIndirectionOperand(*this, Input.get(), VK, OpLoc, IsAfterAmp);
  break;
}
case UO_Plus:
case UO_Minus:
  CanOverflow = Opc == UO_Minus &&
                isOverflowingIntegerType(Context, Input.get()->getType());
  Input = UsualUnaryConversions(Input.get());
  if (Input.isInvalid()) return ExprError();
  // Unary plus and minus require promoting an operand of half vector to a
  // float vector and truncating the result back to a half vector. For now, we
  // do this only when HalfArgsAndReturns is set (that is, when the target is
  // arm or arm64).
  ConvertHalfVec = needsConversionOfHalfVec(true, Context, Input.get());

  // If the operand is a half vector, promote it to a float vector.
  if (ConvertHalfVec)
    Input = convertVector(Input.get(), Context.FloatTy, *this);
  resultType = Input.get()->getType();
  if (resultType->isDependentType())
    break;
  if (resultType->isArithmeticType()) // C99 6.5.3.3p1
    break;
  else if (resultType->isVectorType() &&
           // The z vector extensions don't allow + or - with bool vectors.
           (!Context.getLangOpts().ZVector ||
            resultType->castAs<VectorType>()->getVectorKind() !=
            VectorType::AltiVecBool))
    break;
  else if (resultType->isVLSTBuiltinType()) // SVE vectors allow + and -
    break;
  else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
           Opc == UO_Plus &&
           resultType->isPointerType())
    break;

  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
    << resultType << Input.get()->getSourceRange());

case UO_Not: // bitwise complement
  Input = UsualUnaryConversions(Input.get());
  if (Input.isInvalid())
    return ExprError();
  resultType = Input.get()->getType();
  if (resultType->isDependentType())
    break;
  // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
  if (resultType->isComplexType() || resultType->isComplexIntegerType())
    // C99 does not support '~' for complex conjugation.
    Diag(OpLoc, diag::ext_integer_complement_complex)
        << resultType << Input.get()->getSourceRange();
  else if (resultType->hasIntegerRepresentation())
    break;
  else if (resultType->isExtVectorType() && Context.getLangOpts().OpenCL) {
    // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate
    // on vector float types.
    QualType T = resultType->castAs<ExtVectorType>()->getElementType();
    if (!T->isIntegerType())
      return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                        << resultType << Input.get()->getSourceRange());
  } else {
    return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                     << resultType << Input.get()->getSourceRange());
  }
  break;

case UO_LNot: // logical negation
  // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
  Input = DefaultFunctionArrayLvalueConversion(Input.get());
  if (Input.isInvalid()) return ExprError();
  resultType = Input.get()->getType();

  // Though we still have to promote half FP to float...
  if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) {
    Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get();
    resultType = Context.FloatTy;
  }

  if (resultType->isDependentType())
    break;
  if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) {
    // C99 6.5.3.3p1: ok, fallthrough;
    if (Context.getLangOpts().CPlusPlus) {
      // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9:
      // operand contextually converted to bool.
      Input = ImpCastExprToType(Input.get(), Context.BoolTy,
                                ScalarTypeToBooleanCastKind(resultType));
    } else if (Context.getLangOpts().OpenCL &&
               Context.getLangOpts().OpenCLVersion < 120) {
      // OpenCL v1.1 6.3.h: The logical operator not (!) does not
      // operate on scalar float types.
      if (!resultType->isIntegerType() && !resultType->isPointerType())
        return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                         << resultType << Input.get()->getSourceRange());
    }
  } else if (resultType->isExtVectorType()) {
    if (Context.getLangOpts().OpenCL &&
        Context.getLangOpts().getOpenCLCompatibleVersion() < 120) {
      // OpenCL v1.1 6.3.h: The logical operator not (!) does not
      // operate on vector float types.
      QualType T = resultType->castAs<ExtVectorType>()->getElementType();
      if (!T->isIntegerType())
        return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                         << resultType << Input.get()->getSourceRange());
    }
    // Vector logical not returns the signed variant of the operand type.
    resultType = GetSignedVectorType(resultType);
    break;
  } else if (Context.getLangOpts().CPlusPlus && resultType->isVectorType()) {
    const VectorType *VTy = resultType->castAs<VectorType>();
    if (VTy->getVectorKind() != VectorType::GenericVector)
      return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                       << resultType << Input.get()->getSourceRange());

    // Vector logical not returns the signed variant of the operand type.
    resultType = GetSignedVectorType(resultType);
    break;
  } else {
    return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
      << resultType << Input.get()->getSourceRange());
  }

  // LNot always has type int. C99 6.5.3.3p5.
  // In C++, it's bool. C++ 5.3.1p8
  resultType = Context.getLogicalOperationType();
  break;
case UO_Real:
case UO_Imag:
  resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real);
  // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary
  // complex l-values to ordinary l-values and all other values to r-values.
  if (Input.isInvalid()) return ExprError();
  if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) {
    if (Input.get()->isGLValue() &&
        Input.get()->getObjectKind() == OK_Ordinary)
      VK = Input.get()->getValueKind();
  } else if (!getLangOpts().CPlusPlus) {
    // In C, a volatile scalar is read by __imag. In C++, it is not.
    Input = DefaultLvalueConversion(Input.get());
  }
  break;
case UO_Extension:
  resultType = Input.get()->getType();
  VK = Input.get()->getValueKind();
  OK = Input.get()->getObjectKind();
  break;
case UO_Coawait:
  // It's unnecessary to represent the pass-through operator co_await in the
  // AST; just return the input expression instead.
  assert(!Input.get()->getType()->isDependentType() &&(static_cast <bool> (!Input.get()->getType()->isDependentType
() && "the co_await expression must be non-dependant before "
 "building operator co_await") ? void (0) : __assert_fail ("!Input.get()->getType()->isDependentType() && \"the co_await expression must be non-dependant before \" \"building operator co_await\""
, "clang/lib/Sema/SemaExpr.cpp", 16146, __extension__ __PRETTY_FUNCTION__
))
                 "the co_await expression must be non-dependant before "(static_cast <bool> (!Input.get()->getType()->isDependentType
() && "the co_await expression must be non-dependant before "
 "building operator co_await") ? void (0) : __assert_fail ("!Input.get()->getType()->isDependentType() && \"the co_await expression must be non-dependant before \" \"building operator co_await\""
, "clang/lib/Sema/SemaExpr.cpp", 16146, __extension__ __PRETTY_FUNCTION__
))
                 "building operator co_await")(static_cast <bool> (!Input.get()->getType()->isDependentType
() && "the co_await expression must be non-dependant before "
 "building operator co_await") ? void (0) : __assert_fail ("!Input.get()->getType()->isDependentType() && \"the co_await expression must be non-dependant before \" \"building operator co_await\""
, "clang/lib/Sema/SemaExpr.cpp", 16146, __extension__ __PRETTY_FUNCTION__
));
  return Input;
}
if (resultType.isNull() || Input.isInvalid())
  return ExprError();

// Check for array bounds violations in the operand of the UnaryOperator,
// except for the '*' and '&' operators that have to be handled specially
// by CheckArrayAccess (as there are special cases like &array[arraysize]
// that are explicitly defined as valid by the standard).
if (Opc != UO_AddrOf && Opc != UO_Deref)
  CheckArrayAccess(Input.get());

auto *UO =
    UnaryOperator::Create(Context, Input.get(), Opc, resultType, VK, OK,
                          OpLoc, CanOverflow, CurFPFeatureOverrides());

if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
    !isa<ArrayType>(UO->getType().getDesugaredType(Context)) &&
    !isUnevaluatedContext())
  ExprEvalContexts.back().PossibleDerefs.insert(UO);

// Convert the result back to a half vector.
if (ConvertHalfVec)
  return convertVector(UO, Context.HalfTy, *this);
return UO;
16172}

16174/// Determine whether the given expression is a qualified member
16175/// access expression, of a form that could be turned into a pointer to member
16176/// with the address-of operator.
16177bool Sema::isQualifiedMemberAccess(Expr *E) {
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
  if (!DRE->getQualifier())
    return false;

  ValueDecl *VD = DRE->getDecl();
  if (!VD->isCXXClassMember())
    return false;

  if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
    return true;
  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD))
    return Method->isInstance();

  return false;
}

if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
  if (!ULE->getQualifier())
    return false;

  for (NamedDecl *D : ULE->decls()) {
    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
      if (Method->isInstance())
        return true;
    } else {
      // Overload set does not contain methods.
      break;
    }
  }

  return false;
}

return false;
16212}

16214ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
                            UnaryOperatorKind Opc, Expr *Input,
                            bool IsAfterAmp) {
// First things first: handle placeholders so that the
// overloaded-operator check considers the right type.
if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) {
  // Increment and decrement of pseudo-object references.
  if (pty->getKind() == BuiltinType::PseudoObject &&
      UnaryOperator::isIncrementDecrementOp(Opc))
    return checkPseudoObjectIncDec(S, OpLoc, Opc, Input);

  // extension is always a builtin operator.
  if (Opc == UO_Extension)
    return CreateBuiltinUnaryOp(OpLoc, Opc, Input);

  // & gets special logic for several kinds of placeholder.
  // The builtin code knows what to do.
  if (Opc == UO_AddrOf &&
      (pty->getKind() == BuiltinType::Overload ||
       pty->getKind() == BuiltinType::UnknownAny ||
       pty->getKind() == BuiltinType::BoundMember))
    return CreateBuiltinUnaryOp(OpLoc, Opc, Input);

  // Anything else needs to be handled now.
  ExprResult Result = CheckPlaceholderExpr(Input);
  if (Result.isInvalid()) return ExprError();
  Input = Result.get();
}

if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() &&
    UnaryOperator::getOverloadedOperator(Opc) != OO_None &&
    !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) {
  // Find all of the overloaded operators visible from this point.
  UnresolvedSet<16> Functions;
  OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
  if (S && OverOp != OO_None)
    LookupOverloadedOperatorName(OverOp, S, Functions);

  return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
}

return CreateBuiltinUnaryOp(OpLoc, Opc, Input, IsAfterAmp);
16256}

16258// Unary Operators.  'Tok' is the token for the operator.
16259ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op,
                            Expr *Input, bool IsAfterAmp) {
return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input,
                    IsAfterAmp);
16263}

16265/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
16266ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
                              LabelDecl *TheDecl) {
TheDecl->markUsed(Context);
// Create the AST node.  The address of a label always has type 'void*'.
auto *Res = new (Context) AddrLabelExpr(
    OpLoc, LabLoc, TheDecl, Context.getPointerType(Context.VoidTy));

if (getCurFunction())
  getCurFunction()->AddrLabels.push_back(Res);

return Res;
16277}

16279void Sema::ActOnStartStmtExpr() {
PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
16281}

16283void Sema::ActOnStmtExprError() {
// Note that function is also called by TreeTransform when leaving a
// StmtExpr scope without rebuilding anything.

DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();
16289}

16291ExprResult Sema::ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
                             SourceLocation RPLoc) {
return BuildStmtExpr(LPLoc, SubStmt, RPLoc, getTemplateDepth(S));
16294}

16296ExprResult Sema::BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
                             SourceLocation RPLoc, unsigned TemplateDepth) {
assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!")(static_cast <bool> (SubStmt && isa<CompoundStmt
>(SubStmt) && "Invalid action invocation!") ? void
 (0) : __assert_fail ("SubStmt && isa<CompoundStmt>(SubStmt) && \"Invalid action invocation!\""
, "clang/lib/Sema/SemaExpr.cpp", 16298, __extension__ __PRETTY_FUNCTION__
));
CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);

if (hasAnyUnrecoverableErrorsInThisFunction())
  DiscardCleanupsInEvaluationContext();
assert(!Cleanup.exprNeedsCleanups() &&(static_cast <bool> (!Cleanup.exprNeedsCleanups() &&
 "cleanups within StmtExpr not correctly bound!") ? void (0) :
 __assert_fail ("!Cleanup.exprNeedsCleanups() && \"cleanups within StmtExpr not correctly bound!\""
, "clang/lib/Sema/SemaExpr.cpp", 16304, __extension__ __PRETTY_FUNCTION__
))
       "cleanups within StmtExpr not correctly bound!")(static_cast <bool> (!Cleanup.exprNeedsCleanups() &&
 "cleanups within StmtExpr not correctly bound!") ? void (0) :
 __assert_fail ("!Cleanup.exprNeedsCleanups() && \"cleanups within StmtExpr not correctly bound!\""
, "clang/lib/Sema/SemaExpr.cpp", 16304, __extension__ __PRETTY_FUNCTION__
));
PopExpressionEvaluationContext();

// FIXME: there are a variety of strange constraints to enforce here, for
// example, it is not possible to goto into a stmt expression apparently.
// More semantic analysis is needed.

// If there are sub-stmts in the compound stmt, take the type of the last one
// as the type of the stmtexpr.
QualType Ty = Context.VoidTy;
bool StmtExprMayBindToTemp = false;
if (!Compound->body_empty()) {
  // For GCC compatibility we get the last Stmt excluding trailing NullStmts.
  if (const auto *LastStmt =
          dyn_cast<ValueStmt>(Compound->getStmtExprResult())) {
    if (const Expr *Value = LastStmt->getExprStmt()) {
      StmtExprMayBindToTemp = true;
      Ty = Value->getType();
    }
  }
}

// FIXME: Check that expression type is complete/non-abstract; statement
// expressions are not lvalues.
Expr *ResStmtExpr =
    new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc, TemplateDepth);
if (StmtExprMayBindToTemp)
  return MaybeBindToTemporary(ResStmtExpr);
return ResStmtExpr;
16333}

16335ExprResult Sema::ActOnStmtExprResult(ExprResult ER) {
if (ER.isInvalid())
  return ExprError();

// Do function/array conversion on the last expression, but not
// lvalue-to-rvalue.  However, initialize an unqualified type.
ER = DefaultFunctionArrayConversion(ER.get());
if (ER.isInvalid())
  return ExprError();
Expr *E = ER.get();

if (E->isTypeDependent())
  return E;

// In ARC, if the final expression ends in a consume, splice
// the consume out and bind it later.  In the alternate case
// (when dealing with a retainable type), the result
// initialization will create a produce.  In both cases the
// result will be +1, and we'll need to balance that out with
// a bind.
auto *Cast = dyn_cast<ImplicitCastExpr>(E);
if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
  return Cast->getSubExpr();

// FIXME: Provide a better location for the initialization.
return PerformCopyInitialization(
    InitializedEntity::InitializeStmtExprResult(
        E->getBeginLoc(), E->getType().getUnqualifiedType()),
    SourceLocation(), E);
16364}

16366ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
                                    TypeSourceInfo *TInfo,
                                    ArrayRef<OffsetOfComponent> Components,
                                    SourceLocation RParenLoc) {
QualType ArgTy = TInfo->getType();
bool Dependent = ArgTy->isDependentType();
SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange();

// We must have at least one component that refers to the type, and the first
// one is known to be a field designator.  Verify that the ArgTy represents
// a struct/union/class.
if (!Dependent && !ArgTy->isRecordType())
  return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
                     << ArgTy << TypeRange);

// Type must be complete per C99 7.17p3 because a declaring a variable
// with an incomplete type would be ill-formed.
if (!Dependent
    && RequireCompleteType(BuiltinLoc, ArgTy,
                           diag::err_offsetof_incomplete_type, TypeRange))
  return ExprError();

bool DidWarnAboutNonPOD = false;
QualType CurrentType = ArgTy;
SmallVector<OffsetOfNode, 4> Comps;
SmallVector<Expr*, 4> Exprs;
for (const OffsetOfComponent &OC : Components) {
  if (OC.isBrackets) {
    // Offset of an array sub-field.  TODO: Should we allow vector elements?
    if (!CurrentType->isDependentType()) {
      const ArrayType *AT = Context.getAsArrayType(CurrentType);
      if(!AT)
        return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
                         << CurrentType);
      CurrentType = AT->getElementType();
    } else
      CurrentType = Context.DependentTy;

    ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
    if (IdxRval.isInvalid())
      return ExprError();
    Expr *Idx = IdxRval.get();

    // The expression must be an integral expression.
    // FIXME: An integral constant expression?
    if (!Idx->isTypeDependent() && !Idx->isValueDependent() &&
        !Idx->getType()->isIntegerType())
      return ExprError(
          Diag(Idx->getBeginLoc(), diag::err_typecheck_subscript_not_integer)
          << Idx->getSourceRange());

    // Record this array index.
    Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
    Exprs.push_back(Idx);
    continue;
  }

  // Offset of a field.
  if (CurrentType->isDependentType()) {
    // We have the offset of a field, but we can't look into the dependent
    // type. Just record the identifier of the field.
    Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
    CurrentType = Context.DependentTy;
    continue;
  }

  // We need to have a complete type to look into.
  if (RequireCompleteType(OC.LocStart, CurrentType,
                          diag::err_offsetof_incomplete_type))
    return ExprError();

  // Look for the designated field.
  const RecordType *RC = CurrentType->getAs<RecordType>();
  if (!RC)
    return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
                     << CurrentType);
  RecordDecl *RD = RC->getDecl();

  // C++ [lib.support.types]p5:
  //   The macro offsetof accepts a restricted set of type arguments in this
  //   International Standard. type shall be a POD structure or a POD union
  //   (clause 9).
  // C++11 [support.types]p4:
  //   If type is not a standard-layout class (Clause 9), the results are
  //   undefined.
  if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
    bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
    unsigned DiagID =
      LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
                          : diag::ext_offsetof_non_pod_type;

    if (!IsSafe && !DidWarnAboutNonPOD &&
        DiagRuntimeBehavior(BuiltinLoc, nullptr,
                            PDiag(DiagID)
                            << SourceRange(Components[0].LocStart, OC.LocEnd)
                            << CurrentType))
      DidWarnAboutNonPOD = true;
  }

  // Look for the field.
  LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName);
  LookupQualifiedName(R, RD);
  FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>();
  IndirectFieldDecl *IndirectMemberDecl = nullptr;
  if (!MemberDecl) {
    if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>()))
      MemberDecl = IndirectMemberDecl->getAnonField();
  }

  if (!MemberDecl)
    return ExprError(Diag(BuiltinLoc, diag::err_no_member)
                     << OC.U.IdentInfo << RD << SourceRange(OC.LocStart,
                                                            OC.LocEnd));

  // C99 7.17p3:
  //   (If the specified member is a bit-field, the behavior is undefined.)
  //
  // We diagnose this as an error.
  if (MemberDecl->isBitField()) {
    Diag(OC.LocEnd, diag::err_offsetof_bitfield)
      << MemberDecl->getDeclName()
      << SourceRange(BuiltinLoc, RParenLoc);
    Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
    return ExprError();
  }

  RecordDecl *Parent = MemberDecl->getParent();
  if (IndirectMemberDecl)
    Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());

  // If the member was found in a base class, introduce OffsetOfNodes for
  // the base class indirections.
  CXXBasePaths Paths;
  if (IsDerivedFrom(OC.LocStart, CurrentType, Context.getTypeDeclType(Parent),
                    Paths)) {
    if (Paths.getDetectedVirtual()) {
      Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
        << MemberDecl->getDeclName()
        << SourceRange(BuiltinLoc, RParenLoc);
      return ExprError();
    }

    CXXBasePath &Path = Paths.front();
    for (const CXXBasePathElement &B : Path)
      Comps.push_back(OffsetOfNode(B.Base));
  }

  if (IndirectMemberDecl) {
    for (auto *FI : IndirectMemberDecl->chain()) {
      assert(isa<FieldDecl>(FI))(static_cast <bool> (isa<FieldDecl>(FI)) ? void (
0) : __assert_fail ("isa<FieldDecl>(FI)", "clang/lib/Sema/SemaExpr.cpp"
, 16515, __extension__ __PRETTY_FUNCTION__));
      Comps.push_back(OffsetOfNode(OC.LocStart,
                                   cast<FieldDecl>(FI), OC.LocEnd));
    }
  } else
    Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));

  CurrentType = MemberDecl->getType().getNonReferenceType();
}

return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo,
                            Comps, Exprs, RParenLoc);
16527}

16529ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
                                    SourceLocation BuiltinLoc,
                                    SourceLocation TypeLoc,
                                    ParsedType ParsedArgTy,
                                    ArrayRef<OffsetOfComponent> Components,
                                    SourceLocation RParenLoc) {

TypeSourceInfo *ArgTInfo;
QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo);
if (ArgTy.isNull())
  return ExprError();

if (!ArgTInfo)
  ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc);

return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, Components, RParenLoc);
16545}


16548ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
                               Expr *CondExpr,
                               Expr *LHSExpr, Expr *RHSExpr,
                               SourceLocation RPLoc) {
assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)")(static_cast <bool> ((CondExpr && LHSExpr &&
 RHSExpr) && "Missing type argument(s)") ? void (0) :
 __assert_fail ("(CondExpr && LHSExpr && RHSExpr) && \"Missing type argument(s)\""
, "clang/lib/Sema/SemaExpr.cpp", 16552, __extension__ __PRETTY_FUNCTION__
));

ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
QualType resType;
bool CondIsTrue = false;
if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
  resType = Context.DependentTy;
} else {
  // The conditional expression is required to be a constant expression.
  llvm::APSInt condEval(32);
  ExprResult CondICE = VerifyIntegerConstantExpression(
      CondExpr, &condEval, diag::err_typecheck_choose_expr_requires_constant);
  if (CondICE.isInvalid())
    return ExprError();
  CondExpr = CondICE.get();
  CondIsTrue = condEval.getZExtValue();

  // If the condition is > zero, then the AST type is the same as the LHSExpr.
  Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;

  resType = ActiveExpr->getType();
  VK = ActiveExpr->getValueKind();
  OK = ActiveExpr->getObjectKind();
}

return new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
                                resType, VK, OK, RPLoc, CondIsTrue);
16580}

16582//===----------------------------------------------------------------------===//
16583// Clang Extensions.
16584//===----------------------------------------------------------------------===//

16586/// ActOnBlockStart - This callback is invoked when a block literal is started.
16587void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) {
BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc);

if (LangOpts.CPlusPlus) {
  MangleNumberingContext *MCtx;
  Decl *ManglingContextDecl;
  std::tie(MCtx, ManglingContextDecl) =
      getCurrentMangleNumberContext(Block->getDeclContext());
  if (MCtx) {
    unsigned ManglingNumber = MCtx->getManglingNumber(Block);
    Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
  }
}

PushBlockScope(CurScope, Block);
CurContext->addDecl(Block);
if (CurScope)
  PushDeclContext(CurScope, Block);
else
  CurContext = Block;

getCurBlock()->HasImplicitReturnType = true;

// Enter a new evaluation context to insulate the block from any
// cleanups from the enclosing full-expression.
PushExpressionEvaluationContext(
    ExpressionEvaluationContext::PotentiallyEvaluated);
16614}

16616void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
                             Scope *CurScope) {
assert(ParamInfo.getIdentifier() == nullptr &&(static_cast <bool> (ParamInfo.getIdentifier() == nullptr
 && "block-id should have no identifier!") ? void (0)
 : __assert_fail ("ParamInfo.getIdentifier() == nullptr && \"block-id should have no identifier!\""
, "clang/lib/Sema/SemaExpr.cpp", 16619, __extension__ __PRETTY_FUNCTION__
))
       "block-id should have no identifier!")(static_cast <bool> (ParamInfo.getIdentifier() == nullptr
 && "block-id should have no identifier!") ? void (0)
 : __assert_fail ("ParamInfo.getIdentifier() == nullptr && \"block-id should have no identifier!\""
, "clang/lib/Sema/SemaExpr.cpp", 16619, __extension__ __PRETTY_FUNCTION__
));
assert(ParamInfo.getContext() == DeclaratorContext::BlockLiteral)(static_cast <bool> (ParamInfo.getContext() == DeclaratorContext
::BlockLiteral) ? void (0) : __assert_fail ("ParamInfo.getContext() == DeclaratorContext::BlockLiteral"
, "clang/lib/Sema/SemaExpr.cpp", 16620, __extension__ __PRETTY_FUNCTION__
));
BlockScopeInfo *CurBlock = getCurBlock();

TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope);
QualType T = Sig->getType();

// FIXME: We should allow unexpanded parameter packs here, but that would,
// in turn, make the block expression contain unexpanded parameter packs.
if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) {
  // Drop the parameters.
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.HasTrailingReturn = false;
  EPI.TypeQuals.addConst();
  T = Context.getFunctionType(Context.DependentTy, std::nullopt, EPI);
  Sig = Context.getTrivialTypeSourceInfo(T);
}

// GetTypeForDeclarator always produces a function type for a block
// literal signature.  Furthermore, it is always a FunctionProtoType
// unless the function was written with a typedef.
assert(T->isFunctionType() &&(static_cast <bool> (T->isFunctionType() && "GetTypeForDeclarator made a non-function block signature"
) ? void (0) : __assert_fail ("T->isFunctionType() && \"GetTypeForDeclarator made a non-function block signature\""
, "clang/lib/Sema/SemaExpr.cpp", 16641, __extension__ __PRETTY_FUNCTION__
))
       "GetTypeForDeclarator made a non-function block signature")(static_cast <bool> (T->isFunctionType() && "GetTypeForDeclarator made a non-function block signature"
) ? void (0) : __assert_fail ("T->isFunctionType() && \"GetTypeForDeclarator made a non-function block signature\""
, "clang/lib/Sema/SemaExpr.cpp", 16641, __extension__ __PRETTY_FUNCTION__
));

// Look for an explicit signature in that function type.
FunctionProtoTypeLoc ExplicitSignature;

if ((ExplicitSignature = Sig->getTypeLoc()
                             .getAsAdjusted<FunctionProtoTypeLoc>())) {

  // Check whether that explicit signature was synthesized by
  // GetTypeForDeclarator.  If so, don't save that as part of the
  // written signature.
  if (ExplicitSignature.getLocalRangeBegin() ==
      ExplicitSignature.getLocalRangeEnd()) {
    // This would be much cheaper if we stored TypeLocs instead of
    // TypeSourceInfos.
    TypeLoc Result = ExplicitSignature.getReturnLoc();
    unsigned Size = Result.getFullDataSize();
    Sig = Context.CreateTypeSourceInfo(Result.getType(), Size);
    Sig->getTypeLoc().initializeFullCopy(Result, Size);

    ExplicitSignature = FunctionProtoTypeLoc();
  }
}

CurBlock->TheDecl->setSignatureAsWritten(Sig);
CurBlock->FunctionType = T;

const auto *Fn = T->castAs<FunctionType>();
QualType RetTy = Fn->getReturnType();
bool isVariadic =
    (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());

CurBlock->TheDecl->setIsVariadic(isVariadic);

// Context.DependentTy is used as a placeholder for a missing block
// return type.  TODO:  what should we do with declarators like:
//   ^ * { ... }
// If the answer is "apply template argument deduction"....
if (RetTy != Context.DependentTy) {
  CurBlock->ReturnType = RetTy;
  CurBlock->TheDecl->setBlockMissingReturnType(false);
  CurBlock->HasImplicitReturnType = false;
}

// Push block parameters from the declarator if we had them.
SmallVector<ParmVarDecl*, 8> Params;
if (ExplicitSignature) {
  for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) {
    ParmVarDecl *Param = ExplicitSignature.getParam(I);
    if (Param->getIdentifier() == nullptr && !Param->isImplicit() &&
        !Param->isInvalidDecl() && !getLangOpts().CPlusPlus) {
      // Diagnose this as an extension in C17 and earlier.
      if (!getLangOpts().C2x)
        Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c2x);
    }
    Params.push_back(Param);
  }

// Fake up parameter variables if we have a typedef, like
//   ^ fntype { ... }
} else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
  for (const auto &I : Fn->param_types()) {
    ParmVarDecl *Param = BuildParmVarDeclForTypedef(
        CurBlock->TheDecl, ParamInfo.getBeginLoc(), I);
    Params.push_back(Param);
  }
}

// Set the parameters on the block decl.
if (!Params.empty()) {
  CurBlock->TheDecl->setParams(Params);
  CheckParmsForFunctionDef(CurBlock->TheDecl->parameters(),
                           /*CheckParameterNames=*/false);
}

// Finally we can process decl attributes.
ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);

// Put the parameter variables in scope.
for (auto *AI : CurBlock->TheDecl->parameters()) {
  AI->setOwningFunction(CurBlock->TheDecl);

  // If this has an identifier, add it to the scope stack.
  if (AI->getIdentifier()) {
    CheckShadow(CurBlock->TheScope, AI);

    PushOnScopeChains(AI, CurBlock->TheScope);
  }
}
16730}

16732/// ActOnBlockError - If there is an error parsing a block, this callback
16733/// is invoked to pop the information about the block from the action impl.
16734void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
// Leave the expression-evaluation context.
DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();

// Pop off CurBlock, handle nested blocks.
PopDeclContext();
PopFunctionScopeInfo();
16742}

16744/// ActOnBlockStmtExpr - This is called when the body of a block statement
16745/// literal was successfully completed.  ^(int x){...}
16746ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
                                  Stmt *Body, Scope *CurScope) {
// If blocks are disabled, emit an error.
if (!LangOpts.Blocks)
  Diag(CaretLoc, diag::err_blocks_disable) << LangOpts.OpenCL;

// Leave the expression-evaluation context.
if (hasAnyUnrecoverableErrorsInThisFunction())
  DiscardCleanupsInEvaluationContext();
assert(!Cleanup.exprNeedsCleanups() &&(static_cast <bool> (!Cleanup.exprNeedsCleanups() &&
 "cleanups within block not correctly bound!") ? void (0) : __assert_fail
 ("!Cleanup.exprNeedsCleanups() && \"cleanups within block not correctly bound!\""
, "clang/lib/Sema/SemaExpr.cpp", 16756, __extension__ __PRETTY_FUNCTION__
))
       "cleanups within block not correctly bound!")(static_cast <bool> (!Cleanup.exprNeedsCleanups() &&
 "cleanups within block not correctly bound!") ? void (0) : __assert_fail
 ("!Cleanup.exprNeedsCleanups() && \"cleanups within block not correctly bound!\""
, "clang/lib/Sema/SemaExpr.cpp", 16756, __extension__ __PRETTY_FUNCTION__
));
PopExpressionEvaluationContext();

BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back());
BlockDecl *BD = BSI->TheDecl;

if (BSI->HasImplicitReturnType)
  deduceClosureReturnType(*BSI);

QualType RetTy = Context.VoidTy;
if (!BSI->ReturnType.isNull())
  RetTy = BSI->ReturnType;

bool NoReturn = BD->hasAttr<NoReturnAttr>();
QualType BlockTy;

// If the user wrote a function type in some form, try to use that.
if (!BSI->FunctionType.isNull()) {
  const FunctionType *FTy = BSI->FunctionType->castAs<FunctionType>();

  FunctionType::ExtInfo Ext = FTy->getExtInfo();
  if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);

  // Turn protoless block types into nullary block types.
  if (isa<FunctionNoProtoType>(FTy)) {
    FunctionProtoType::ExtProtoInfo EPI;
    EPI.ExtInfo = Ext;
    BlockTy = Context.getFunctionType(RetTy, std::nullopt, EPI);

    // Otherwise, if we don't need to change anything about the function type,
    // preserve its sugar structure.
  } else if (FTy->getReturnType() == RetTy &&
             (!NoReturn || FTy->getNoReturnAttr())) {
    BlockTy = BSI->FunctionType;

  // Otherwise, make the minimal modifications to the function type.
  } else {
    const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
    FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
    EPI.TypeQuals = Qualifiers();
    EPI.ExtInfo = Ext;
    BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI);
  }

// If we don't have a function type, just build one from nothing.
} else {
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn);
  BlockTy = Context.getFunctionType(RetTy, std::nullopt, EPI);
}

DiagnoseUnusedParameters(BD->parameters());
BlockTy = Context.getBlockPointerType(BlockTy);

// If needed, diagnose invalid gotos and switches in the block.
if (getCurFunction()->NeedsScopeChecking() &&
    !PP.isCodeCompletionEnabled())
  DiagnoseInvalidJumps(cast<CompoundStmt>(Body));

BD->setBody(cast<CompoundStmt>(Body));

if (Body && getCurFunction()->HasPotentialAvailabilityViolations)
  DiagnoseUnguardedAvailabilityViolations(BD);

// Try to apply the named return value optimization. We have to check again
// if we can do this, though, because blocks keep return statements around
// to deduce an implicit return type.
if (getLangOpts().CPlusPlus && RetTy->isRecordType() &&
    !BD->isDependentContext())
  computeNRVO(Body, BSI);

if (RetTy.hasNonTrivialToPrimitiveDestructCUnion() ||
    RetTy.hasNonTrivialToPrimitiveCopyCUnion())
  checkNonTrivialCUnion(RetTy, BD->getCaretLocation(), NTCUC_FunctionReturn,
                        NTCUK_Destruct|NTCUK_Copy);

PopDeclContext();

// Set the captured variables on the block.
SmallVector<BlockDecl::Capture, 4> Captures;
for (Capture &Cap : BSI->Captures) {
  if (Cap.isInvalid() || Cap.isThisCapture())
    continue;
  // Cap.getVariable() is always a VarDecl because
  // blocks cannot capture structured bindings or other ValueDecl kinds.
  auto *Var = cast<VarDecl>(Cap.getVariable());
  Expr *CopyExpr = nullptr;
  if (getLangOpts().CPlusPlus && Cap.isCopyCapture()) {
    if (const RecordType *Record =
            Cap.getCaptureType()->getAs<RecordType>()) {
      // The capture logic needs the destructor, so make sure we mark it.
      // Usually this is unnecessary because most local variables have
      // their destructors marked at declaration time, but parameters are
      // an exception because it's technically only the call site that
      // actually requires the destructor.
      if (isa<ParmVarDecl>(Var))
        FinalizeVarWithDestructor(Var, Record);

      // Enter a separate potentially-evaluated context while building block
      // initializers to isolate their cleanups from those of the block
      // itself.
      // FIXME: Is this appropriate even when the block itself occurs in an
      // unevaluated operand?
      EnterExpressionEvaluationContext EvalContext(
          *this, ExpressionEvaluationContext::PotentiallyEvaluated);

      SourceLocation Loc = Cap.getLocation();

      ExprResult Result = BuildDeclarationNameExpr(
          CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);

      // According to the blocks spec, the capture of a variable from
      // the stack requires a const copy constructor.  This is not true
      // of the copy/move done to move a __block variable to the heap.
      if (!Result.isInvalid() &&
          !Result.get()->getType().isConstQualified()) {
        Result = ImpCastExprToType(Result.get(),
                                   Result.get()->getType().withConst(),
                                   CK_NoOp, VK_LValue);
      }

      if (!Result.isInvalid()) {
        Result = PerformCopyInitialization(
            InitializedEntity::InitializeBlock(Var->getLocation(),
                                               Cap.getCaptureType()),
            Loc, Result.get());
      }

      // Build a full-expression copy expression if initialization
      // succeeded and used a non-trivial constructor.  Recover from
      // errors by pretending that the copy isn't necessary.
      if (!Result.isInvalid() &&
          !cast<CXXConstructExpr>(Result.get())->getConstructor()
              ->isTrivial()) {
        Result = MaybeCreateExprWithCleanups(Result);
        CopyExpr = Result.get();
      }
    }
  }

  BlockDecl::Capture NewCap(Var, Cap.isBlockCapture(), Cap.isNested(),
                            CopyExpr);
  Captures.push_back(NewCap);
}
BD->setCaptures(Context, Captures, BSI->CXXThisCaptureIndex != 0);

// Pop the block scope now but keep it alive to the end of this function.
AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
PoppedFunctionScopePtr ScopeRAII = PopFunctionScopeInfo(&WP, BD, BlockTy);

BlockExpr *Result = new (Context) BlockExpr(BD, BlockTy);

// If the block isn't obviously global, i.e. it captures anything at
// all, then we need to do a few things in the surrounding context:
if (Result->getBlockDecl()->hasCaptures()) {
  // First, this expression has a new cleanup object.
  ExprCleanupObjects.push_back(Result->getBlockDecl());
  Cleanup.setExprNeedsCleanups(true);

  // It also gets a branch-protected scope if any of the captured
  // variables needs destruction.
  for (const auto &CI : Result->getBlockDecl()->captures()) {
    const VarDecl *var = CI.getVariable();
    if (var->getType().isDestructedType() != QualType::DK_none) {
      setFunctionHasBranchProtectedScope();
      break;
    }
  }
}

if (getCurFunction())
  getCurFunction()->addBlock(BD);

return Result;
16930}

16932ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
                          SourceLocation RPLoc) {
TypeSourceInfo *TInfo;
GetTypeFromParser(Ty, &TInfo);
return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
16937}

16939ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
                              Expr *E, TypeSourceInfo *TInfo,
                              SourceLocation RPLoc) {
Expr *OrigExpr = E;
bool IsMS = false;

// CUDA device code does not support varargs.
if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
  if (const FunctionDecl *F = dyn_cast<FunctionDecl>(CurContext)) {
    CUDAFunctionTarget T = IdentifyCUDATarget(F);
    if (T == CFT_Global || T == CFT_Device || T == CFT_HostDevice)
      return ExprError(Diag(E->getBeginLoc(), diag::err_va_arg_in_device));
  }
}

// NVPTX does not support va_arg expression.
if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&
    Context.getTargetInfo().getTriple().isNVPTX())
  targetDiag(E->getBeginLoc(), diag::err_va_arg_in_device);

// It might be a __builtin_ms_va_list. (But don't ever mark a va_arg()
// as Microsoft ABI on an actual Microsoft platform, where
// __builtin_ms_va_list and __builtin_va_list are the same.)
if (!E->isTypeDependent() && Context.getTargetInfo().hasBuiltinMSVaList() &&
    Context.getTargetInfo().getBuiltinVaListKind() != TargetInfo::CharPtrBuiltinVaList) {
  QualType MSVaListType = Context.getBuiltinMSVaListType();
  if (Context.hasSameType(MSVaListType, E->getType())) {
    if (CheckForModifiableLvalue(E, BuiltinLoc, *this))
      return ExprError();
    IsMS = true;
  }
}

// Get the va_list type
QualType VaListType = Context.getBuiltinVaListType();
if (!IsMS) {
  if (VaListType->isArrayType()) {
    // Deal with implicit array decay; for example, on x86-64,
    // va_list is an array, but it's supposed to decay to
    // a pointer for va_arg.
    VaListType = Context.getArrayDecayedType(VaListType);
    // Make sure the input expression also decays appropriately.
    ExprResult Result = UsualUnaryConversions(E);
    if (Result.isInvalid())
      return ExprError();
    E = Result.get();
  } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) {
    // If va_list is a record type and we are compiling in C++ mode,
    // check the argument using reference binding.
    InitializedEntity Entity = InitializedEntity::InitializeParameter(
        Context, Context.getLValueReferenceType(VaListType), false);
    ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E);
    if (Init.isInvalid())
      return ExprError();
    E = Init.getAs<Expr>();
  } else {
    // Otherwise, the va_list argument must be an l-value because
    // it is modified by va_arg.
    if (!E->isTypeDependent() &&
        CheckForModifiableLvalue(E, BuiltinLoc, *this))
      return ExprError();
  }
}

if (!IsMS && !E->isTypeDependent() &&
    !Context.hasSameType(VaListType, E->getType()))
  return ExprError(
      Diag(E->getBeginLoc(),
           diag::err_first_argument_to_va_arg_not_of_type_va_list)
      << OrigExpr->getType() << E->getSourceRange());

if (!TInfo->getType()->isDependentType()) {
  if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
                          diag::err_second_parameter_to_va_arg_incomplete,
                          TInfo->getTypeLoc()))
    return ExprError();

  if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
                             TInfo->getType(),
                             diag::err_second_parameter_to_va_arg_abstract,
                             TInfo->getTypeLoc()))
    return ExprError();

  if (!TInfo->getType().isPODType(Context)) {
    Diag(TInfo->getTypeLoc().getBeginLoc(),
         TInfo->getType()->isObjCLifetimeType()
           ? diag::warn_second_parameter_to_va_arg_ownership_qualified
           : diag::warn_second_parameter_to_va_arg_not_pod)
      << TInfo->getType()
      << TInfo->getTypeLoc().getSourceRange();
  }

  // Check for va_arg where arguments of the given type will be promoted
  // (i.e. this va_arg is guaranteed to have undefined behavior).
  QualType PromoteType;
  if (Context.isPromotableIntegerType(TInfo->getType())) {
    PromoteType = Context.getPromotedIntegerType(TInfo->getType());
    // [cstdarg.syn]p1 defers the C++ behavior to what the C standard says,
    // and C2x 7.16.1.1p2 says, in part:
    //   If type is not compatible with the type of the actual next argument
    //   (as promoted according to the default argument promotions), the
    //   behavior is undefined, except for the following cases:
    //     - both types are pointers to qualified or unqualified versions of
    //       compatible types;
    //     - one type is a signed integer type, the other type is the
    //       corresponding unsigned integer type, and the value is
    //       representable in both types;
    //     - one type is pointer to qualified or unqualified void and the
    //       other is a pointer to a qualified or unqualified character type.
    // Given that type compatibility is the primary requirement (ignoring
    // qualifications), you would think we could call typesAreCompatible()
    // directly to test this. However, in C++, that checks for *same type*,
    // which causes false positives when passing an enumeration type to
    // va_arg. Instead, get the underlying type of the enumeration and pass
    // that.
    QualType UnderlyingType = TInfo->getType();
    if (const auto *ET = UnderlyingType->getAs<EnumType>())
      UnderlyingType = ET->getDecl()->getIntegerType();
    if (Context.typesAreCompatible(PromoteType, UnderlyingType,
                                   /*CompareUnqualified*/ true))
      PromoteType = QualType();

    // If the types are still not compatible, we need to test whether the
    // promoted type and the underlying type are the same except for
    // signedness. Ask the AST for the correctly corresponding type and see
    // if that's compatible.
    if (!PromoteType.isNull() && !UnderlyingType->isBooleanType() &&
        PromoteType->isUnsignedIntegerType() !=
            UnderlyingType->isUnsignedIntegerType()) {
      UnderlyingType =
          UnderlyingType->isUnsignedIntegerType()
              ? Context.getCorrespondingSignedType(UnderlyingType)
              : Context.getCorrespondingUnsignedType(UnderlyingType);
      if (Context.typesAreCompatible(PromoteType, UnderlyingType,
                                     /*CompareUnqualified*/ true))
        PromoteType = QualType();
    }
  }
  if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float))
    PromoteType = Context.DoubleTy;
  if (!PromoteType.isNull())
    DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E,
                PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
                        << TInfo->getType()
                        << PromoteType
                        << TInfo->getTypeLoc().getSourceRange());
}

QualType T = TInfo->getType().getNonLValueExprType(Context);
return new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T, IsMS);
17089}

17091ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
// The type of __null will be int or long, depending on the size of
// pointers on the target.
QualType Ty;
unsigned pw = Context.getTargetInfo().getPointerWidth(LangAS::Default);
if (pw == Context.getTargetInfo().getIntWidth())
  Ty = Context.IntTy;
else if (pw == Context.getTargetInfo().getLongWidth())
  Ty = Context.LongTy;
else if (pw == Context.getTargetInfo().getLongLongWidth())
  Ty = Context.LongLongTy;
else {
  llvm_unreachable("I don't know size of pointer!")::llvm::llvm_unreachable_internal("I don't know size of pointer!"
, "clang/lib/Sema/SemaExpr.cpp", 17103);
}

return new (Context) GNUNullExpr(Ty, TokenLoc);
17107}

17109static CXXRecordDecl *LookupStdSourceLocationImpl(Sema &S, SourceLocation Loc) {
CXXRecordDecl *ImplDecl = nullptr;

// Fetch the std::source_location::__impl decl.
if (NamespaceDecl *Std = S.getStdNamespace()) {
  LookupResult ResultSL(S, &S.PP.getIdentifierTable().get("source_location"),
                        Loc, Sema::LookupOrdinaryName);
  if (S.LookupQualifiedName(ResultSL, Std)) {
    if (auto *SLDecl = ResultSL.getAsSingle<RecordDecl>()) {
      LookupResult ResultImpl(S, &S.PP.getIdentifierTable().get("__impl"),
                              Loc, Sema::LookupOrdinaryName);
      if ((SLDecl->isCompleteDefinition() || SLDecl->isBeingDefined()) &&
          S.LookupQualifiedName(ResultImpl, SLDecl)) {
        ImplDecl = ResultImpl.getAsSingle<CXXRecordDecl>();
      }
    }
  }
}

if (!ImplDecl || !ImplDecl->isCompleteDefinition()) {
  S.Diag(Loc, diag::err_std_source_location_impl_not_found);
  return nullptr;
}

// Verify that __impl is a trivial struct type, with no base classes, and with
// only the four expected fields.
if (ImplDecl->isUnion() || !ImplDecl->isStandardLayout() ||
    ImplDecl->getNumBases() != 0) {
  S.Diag(Loc, diag::err_std_source_location_impl_malformed);
  return nullptr;
}

unsigned Count = 0;
for (FieldDecl *F : ImplDecl->fields()) {
  StringRef Name = F->getName();

  if (Name == "_M_file_name") {
    if (F->getType() !=
        S.Context.getPointerType(S.Context.CharTy.withConst()))
      break;
    Count++;
  } else if (Name == "_M_function_name") {
    if (F->getType() !=
        S.Context.getPointerType(S.Context.CharTy.withConst()))
      break;
    Count++;
  } else if (Name == "_M_line") {
    if (!F->getType()->isIntegerType())
      break;
    Count++;
  } else if (Name == "_M_column") {
    if (!F->getType()->isIntegerType())
      break;
    Count++;
  } else {
    Count = 100; // invalid
    break;
  }
}
if (Count != 4) {
  S.Diag(Loc, diag::err_std_source_location_impl_malformed);
  return nullptr;
}

return ImplDecl;
17174}

17176ExprResult Sema::ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                  SourceLocation BuiltinLoc,
                                  SourceLocation RPLoc) {
QualType ResultTy;
switch (Kind) {
case SourceLocExpr::File:
case SourceLocExpr::FileName:
case SourceLocExpr::Function: {
  QualType ArrTy = Context.getStringLiteralArrayType(Context.CharTy, 0);
  ResultTy =
      Context.getPointerType(ArrTy->getAsArrayTypeUnsafe()->getElementType());
  break;
}
case SourceLocExpr::Line:
case SourceLocExpr::Column:
  ResultTy = Context.UnsignedIntTy;
  break;
case SourceLocExpr::SourceLocStruct:
  if (!StdSourceLocationImplDecl) {
    StdSourceLocationImplDecl =
        LookupStdSourceLocationImpl(*this, BuiltinLoc);
    if (!StdSourceLocationImplDecl)
      return ExprError();
  }
  ResultTy = Context.getPointerType(
      Context.getRecordType(StdSourceLocationImplDecl).withConst());
  break;
}

return BuildSourceLocExpr(Kind, ResultTy, BuiltinLoc, RPLoc, CurContext);
17206}

17208ExprResult Sema::BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                  QualType ResultTy,
                                  SourceLocation BuiltinLoc,
                                  SourceLocation RPLoc,
                                  DeclContext *ParentContext) {
return new (Context)
    SourceLocExpr(Context, Kind, ResultTy, BuiltinLoc, RPLoc, ParentContext);
17215}

17217bool Sema::CheckConversionToObjCLiteral(QualType DstType, Expr *&Exp,
                                      bool Diagnose) {
if (!getLangOpts().ObjC)
  return false;

const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>();
if (!PT)
  return false;
const ObjCInterfaceDecl *ID = PT->getInterfaceDecl();

// Ignore any parens, implicit casts (should only be
// array-to-pointer decays), and not-so-opaque values.  The last is
// important for making this trigger for property assignments.
Expr *SrcExpr = Exp->IgnoreParenImpCasts();
if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr))
  if (OV->getSourceExpr())
    SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts();

if (auto *SL = dyn_cast<StringLiteral>(SrcExpr)) {
  if (!PT->isObjCIdType() &&
      !(ID && ID->getIdentifier()->isStr("NSString")))
    return false;
  if (!SL->isOrdinary())
    return false;

  if (Diagnose) {
    Diag(SL->getBeginLoc(), diag::err_missing_atsign_prefix)
        << /*string*/0 << FixItHint::CreateInsertion(SL->getBeginLoc(), "@");
    Exp = BuildObjCStringLiteral(SL->getBeginLoc(), SL).get();
  }
  return true;
}

if ((isa<IntegerLiteral>(SrcExpr) || isa<CharacterLiteral>(SrcExpr) ||
    isa<FloatingLiteral>(SrcExpr) || isa<ObjCBoolLiteralExpr>(SrcExpr) ||
    isa<CXXBoolLiteralExpr>(SrcExpr)) &&
    !SrcExpr->isNullPointerConstant(
        getASTContext(), Expr::NPC_NeverValueDependent)) {
  if (!ID || !ID->getIdentifier()->isStr("NSNumber"))
    return false;
  if (Diagnose) {
    Diag(SrcExpr->getBeginLoc(), diag::err_missing_atsign_prefix)
        << /*number*/1
        << FixItHint::CreateInsertion(SrcExpr->getBeginLoc(), "@");
    Expr *NumLit =
        BuildObjCNumericLiteral(SrcExpr->getBeginLoc(), SrcExpr).get();
    if (NumLit)
      Exp = NumLit;
  }
  return true;
}

return false;
17270}

17272static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType,
                                            const Expr *SrcExpr) {
if (!DstType->isFunctionPointerType() ||
    !SrcExpr->getType()->isFunctionType())
  return false;

auto *DRE = dyn_cast<DeclRefExpr>(SrcExpr->IgnoreParenImpCasts());
if (!DRE)
  return false;

auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
if (!FD)
  return false;

return !S.checkAddressOfFunctionIsAvailable(FD,
                                            /*Complain=*/true,
                                            SrcExpr->getBeginLoc());
17289}

17291bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
                                  SourceLocation Loc,
                                  QualType DstType, QualType SrcType,
                                  Expr *SrcExpr, AssignmentAction Action,
                                  bool *Complained) {
if (Complained)
  *Complained = false;

// Decode the result (notice that AST's are still created for extensions).
bool CheckInferredResultType = false;
bool isInvalid = false;
unsigned DiagKind = 0;
ConversionFixItGenerator ConvHints;
bool MayHaveConvFixit = false;
bool MayHaveFunctionDiff = false;
const ObjCInterfaceDecl *IFace = nullptr;
const ObjCProtocolDecl *PDecl = nullptr;

switch (ConvTy) {
case Compatible:
    DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr);
    return false;

case PointerToInt:
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_typecheck_convert_pointer_int;
    isInvalid = true;
  } else {
    DiagKind = diag::ext_typecheck_convert_pointer_int;
  }
  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
  MayHaveConvFixit = true;
  break;
case IntToPointer:
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_typecheck_convert_int_pointer;
    isInvalid = true;
  } else {
    DiagKind = diag::ext_typecheck_convert_int_pointer;
  }
  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
  MayHaveConvFixit = true;
  break;
case IncompatibleFunctionPointerStrict:
  DiagKind =
      diag::warn_typecheck_convert_incompatible_function_pointer_strict;
  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
  MayHaveConvFixit = true;
  break;
case IncompatibleFunctionPointer:
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
    isInvalid = true;
  } else {
    DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
  }
  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
  MayHaveConvFixit = true;
  break;
case IncompatiblePointer:
  if (Action == AA_Passing_CFAudited) {
    DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
  } else if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_typecheck_convert_incompatible_pointer;
    isInvalid = true;
  } else {
    DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
  }
  CheckInferredResultType = DstType->isObjCObjectPointerType() &&
    SrcType->isObjCObjectPointerType();
  if (!CheckInferredResultType) {
    ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
  } else if (CheckInferredResultType) {
    SrcType = SrcType.getUnqualifiedType();
    DstType = DstType.getUnqualifiedType();
  }
  MayHaveConvFixit = true;
  break;
case IncompatiblePointerSign:
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
    isInvalid = true;
  } else {
    DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
  }
  break;
case FunctionVoidPointer:
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_typecheck_convert_pointer_void_func;
    isInvalid = true;
  } else {
    DiagKind = diag::ext_typecheck_convert_pointer_void_func;
  }
  break;
case IncompatiblePointerDiscardsQualifiers: {
  // Perform array-to-pointer decay if necessary.
  if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);

  isInvalid = true;

  Qualifiers lhq = SrcType->getPointeeType().getQualifiers();
  Qualifiers rhq = DstType->getPointeeType().getQualifiers();
  if (lhq.getAddressSpace() != rhq.getAddressSpace()) {
    DiagKind = diag::err_typecheck_incompatible_address_space;
    break;

  } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) {
    DiagKind = diag::err_typecheck_incompatible_ownership;
    break;
  }

  llvm_unreachable("unknown error case for discarding qualifiers!")::llvm::llvm_unreachable_internal("unknown error case for discarding qualifiers!"
, "clang/lib/Sema/SemaExpr.cpp", 17402);
  // fallthrough
}
case CompatiblePointerDiscardsQualifiers:
  // If the qualifiers lost were because we were applying the
  // (deprecated) C++ conversion from a string literal to a char*
  // (or wchar_t*), then there was no error (C++ 4.2p2).  FIXME:
  // Ideally, this check would be performed in
  // checkPointerTypesForAssignment. However, that would require a
  // bit of refactoring (so that the second argument is an
  // expression, rather than a type), which should be done as part
  // of a larger effort to fix checkPointerTypesForAssignment for
  // C++ semantics.
  if (getLangOpts().CPlusPlus &&
      IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
    return false;
  if (getLangOpts().CPlusPlus) {
    DiagKind =  diag::err_typecheck_convert_discards_qualifiers;
    isInvalid = true;
  } else {
    DiagKind =  diag::ext_typecheck_convert_discards_qualifiers;
  }

  break;
case IncompatibleNestedPointerQualifiers:
  if (getLangOpts().CPlusPlus) {
    isInvalid = true;
    DiagKind = diag::err_nested_pointer_qualifier_mismatch;
  } else {
    DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
  }
  break;
case IncompatibleNestedPointerAddressSpaceMismatch:
  DiagKind = diag::err_typecheck_incompatible_nested_address_space;
  isInvalid = true;
  break;
case IntToBlockPointer:
  DiagKind = diag::err_int_to_block_pointer;
  isInvalid = true;
  break;
case IncompatibleBlockPointer:
  DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
  isInvalid = true;
  break;
case IncompatibleObjCQualifiedId: {
  if (SrcType->isObjCQualifiedIdType()) {
    const ObjCObjectPointerType *srcOPT =
              SrcType->castAs<ObjCObjectPointerType>();
    for (auto *srcProto : srcOPT->quals()) {
      PDecl = srcProto;
      break;
    }
    if (const ObjCInterfaceType *IFaceT =
          DstType->castAs<ObjCObjectPointerType>()->getInterfaceType())
      IFace = IFaceT->getDecl();
  }
  else if (DstType->isObjCQualifiedIdType()) {
    const ObjCObjectPointerType *dstOPT =
      DstType->castAs<ObjCObjectPointerType>();
    for (auto *dstProto : dstOPT->quals()) {
      PDecl = dstProto;
      break;
    }
    if (const ObjCInterfaceType *IFaceT =
          SrcType->castAs<ObjCObjectPointerType>()->getInterfaceType())
      IFace = IFaceT->getDecl();
  }
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_incompatible_qualified_id;
    isInvalid = true;
  } else {
    DiagKind = diag::warn_incompatible_qualified_id;
  }
  break;
}
case IncompatibleVectors:
  if (getLangOpts().CPlusPlus) {
    DiagKind = diag::err_incompatible_vectors;
    isInvalid = true;
  } else {
    DiagKind = diag::warn_incompatible_vectors;
  }
  break;
case IncompatibleObjCWeakRef:
  DiagKind = diag::err_arc_weak_unavailable_assign;
  isInvalid = true;
  break;
case Incompatible:
  if (maybeDiagnoseAssignmentToFunction(*this, DstType, SrcExpr)) {
    if (Complained)
      *Complained = true;
    return true;
  }

  DiagKind = diag::err_typecheck_convert_incompatible;
  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
  MayHaveConvFixit = true;
  isInvalid = true;
  MayHaveFunctionDiff = true;
  break;
}

QualType FirstType, SecondType;
switch (Action) {
case AA_Assigning:
case AA_Initializing:
  // The destination type comes first.
  FirstType = DstType;
  SecondType = SrcType;
  break;

case AA_Returning:
case AA_Passing:
case AA_Passing_CFAudited:
case AA_Converting:
case AA_Sending:
case AA_Casting:
  // The source type comes first.
  FirstType = SrcType;
  SecondType = DstType;
  break;
}

PartialDiagnostic FDiag = PDiag(DiagKind);
AssignmentAction ActionForDiag = Action;
if (Action == AA_Passing_CFAudited)
  ActionForDiag = AA_Passing;

FDiag << FirstType << SecondType << ActionForDiag
      << SrcExpr->getSourceRange();

if (DiagKind == diag::ext_typecheck_convert_incompatible_pointer_sign ||
    DiagKind == diag::err_typecheck_convert_incompatible_pointer_sign) {
  auto isPlainChar = [](const clang::Type *Type) {
    return Type->isSpecificBuiltinType(BuiltinType::Char_S) ||
           Type->isSpecificBuiltinType(BuiltinType::Char_U);
  };
  FDiag << (isPlainChar(FirstType->getPointeeOrArrayElementType()) ||
            isPlainChar(SecondType->getPointeeOrArrayElementType()));
}

// If we can fix the conversion, suggest the FixIts.
if (!ConvHints.isNull()) {
  for (FixItHint &H : ConvHints.Hints)
    FDiag << H;
}

if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }

if (MayHaveFunctionDiff)
  HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);

Diag(Loc, FDiag);
if ((DiagKind == diag::warn_incompatible_qualified_id ||
     DiagKind == diag::err_incompatible_qualified_id) &&
    PDecl && IFace && !IFace->hasDefinition())
  Diag(IFace->getLocation(), diag::note_incomplete_class_and_qualified_id)
      << IFace << PDecl;

if (SecondType == Context.OverloadTy)
  NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
                            FirstType, /*TakingAddress=*/true);

if (CheckInferredResultType)
  EmitRelatedResultTypeNote(SrcExpr);

if (Action == AA_Returning && ConvTy == IncompatiblePointer)
  EmitRelatedResultTypeNoteForReturn(DstType);

if (Complained)
  *Complained = true;
return isInvalid;
17574}

17576ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
                                               llvm::APSInt *Result,
                                               AllowFoldKind CanFold) {
class SimpleICEDiagnoser : public VerifyICEDiagnoser {
public:
  SemaDiagnosticBuilder diagnoseNotICEType(Sema &S, SourceLocation Loc,
                                           QualType T) override {
    return S.Diag(Loc, diag::err_ice_not_integral)
           << T << S.LangOpts.CPlusPlus;
  }
  SemaDiagnosticBuilder diagnoseNotICE(Sema &S, SourceLocation Loc) override {
    return S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus;
  }
} Diagnoser;

return VerifyIntegerConstantExpression(E, Result, Diagnoser, CanFold);
17592}

17594ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
                                               llvm::APSInt *Result,
                                               unsigned DiagID,
                                               AllowFoldKind CanFold) {
class IDDiagnoser : public VerifyICEDiagnoser {
  unsigned DiagID;

public:
  IDDiagnoser(unsigned DiagID)
    : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { }

  SemaDiagnosticBuilder diagnoseNotICE(Sema &S, SourceLocation Loc) override {
    return S.Diag(Loc, DiagID);
  }
} Diagnoser(DiagID);

return VerifyIntegerConstantExpression(E, Result, Diagnoser, CanFold);
17611}

17613Sema::SemaDiagnosticBuilder
17614Sema::VerifyICEDiagnoser::diagnoseNotICEType(Sema &S, SourceLocation Loc,
                                           QualType T) {
return diagnoseNotICE(S, Loc);
17617}

17619Sema::SemaDiagnosticBuilder
17620Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc) {
return S.Diag(Loc, diag::ext_expr_not_ice) << S.LangOpts.CPlusPlus;
17622}

17624ExprResult
17625Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
                                    VerifyICEDiagnoser &Diagnoser,
                                    AllowFoldKind CanFold) {
SourceLocation DiagLoc = E->getBeginLoc();

if (getLangOpts().CPlusPlus11) {
  // C++11 [expr.const]p5:
  //   If an expression of literal class type is used in a context where an
  //   integral constant expression is required, then that class type shall
  //   have a single non-explicit conversion function to an integral or
  //   unscoped enumeration type
  ExprResult Converted;
  class CXX11ConvertDiagnoser : public ICEConvertDiagnoser {
    VerifyICEDiagnoser &BaseDiagnoser;
  public:
    CXX11ConvertDiagnoser(VerifyICEDiagnoser &BaseDiagnoser)
        : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false,
                              BaseDiagnoser.Suppress, true),
          BaseDiagnoser(BaseDiagnoser) {}

    SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
                                         QualType T) override {
      return BaseDiagnoser.diagnoseNotICEType(S, Loc, T);
    }

    SemaDiagnosticBuilder diagnoseIncomplete(
        Sema &S, SourceLocation Loc, QualType T) override {
      return S.Diag(Loc, diag::err_ice_incomplete_type) << T;
    }

    SemaDiagnosticBuilder diagnoseExplicitConv(
        Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
      return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
    }

    SemaDiagnosticBuilder noteExplicitConv(
        Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
      return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
               << ConvTy->isEnumeralType() << ConvTy;
    }

    SemaDiagnosticBuilder diagnoseAmbiguous(
        Sema &S, SourceLocation Loc, QualType T) override {
      return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
    }

    SemaDiagnosticBuilder noteAmbiguous(
        Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
      return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
               << ConvTy->isEnumeralType() << ConvTy;
    }

    SemaDiagnosticBuilder diagnoseConversion(
        Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
      llvm_unreachable("conversion functions are permitted")::llvm::llvm_unreachable_internal("conversion functions are permitted"
, "clang/lib/Sema/SemaExpr.cpp", 17679);
    }
  } ConvertDiagnoser(Diagnoser);

  Converted = PerformContextualImplicitConversion(DiagLoc, E,
                                                  ConvertDiagnoser);
  if (Converted.isInvalid())
    return Converted;
  E = Converted.get();
  if (!E->getType()->isIntegralOrUnscopedEnumerationType())
    return ExprError();
} else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
  // An ICE must be of integral or unscoped enumeration type.
  if (!Diagnoser.Suppress)
    Diagnoser.diagnoseNotICEType(*this, DiagLoc, E->getType())
        << E->getSourceRange();
  return ExprError();
}

ExprResult RValueExpr = DefaultLvalueConversion(E);
if (RValueExpr.isInvalid())
  return ExprError();

E = RValueExpr.get();

// Circumvent ICE checking in C++11 to avoid evaluating the expression twice
// in the non-ICE case.
if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) {
  if (Result)
    *Result = E->EvaluateKnownConstIntCheckOverflow(Context);
  if (!isa<ConstantExpr>(E))
    E = Result ? ConstantExpr::Create(Context, E, APValue(*Result))
               : ConstantExpr::Create(Context, E);
  return E;
}

Expr::EvalResult EvalResult;
SmallVector<PartialDiagnosticAt, 8> Notes;
EvalResult.Diag = &Notes;

// Try to evaluate the expression, and produce diagnostics explaining why it's
// not a constant expression as a side-effect.
bool Folded =
    E->EvaluateAsRValue(EvalResult, Context, /*isConstantContext*/ true) &&
    EvalResult.Val.isInt() && !EvalResult.HasSideEffects;

if (!isa<ConstantExpr>(E))
  E = ConstantExpr::Create(Context, E, EvalResult.Val);

// In C++11, we can rely on diagnostics being produced for any expression
// which is not a constant expression. If no diagnostics were produced, then
// this is a constant expression.
if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
  if (Result)
    *Result = EvalResult.Val.getInt();
  return E;
}

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

if (!Folded || !CanFold) {
  if (!Diagnoser.Suppress) {
    Diagnoser.diagnoseNotICE(*this, DiagLoc) << E->getSourceRange();
    for (const PartialDiagnosticAt &Note : Notes)
      Diag(Note.first, Note.second);
  }

  return ExprError();
}

Diagnoser.diagnoseFold(*this, DiagLoc) << E->getSourceRange();
for (const PartialDiagnosticAt &Note : Notes)
  Diag(Note.first, Note.second);

if (Result)
  *Result = EvalResult.Val.getInt();
return E;
17763}

17765namespace {
// Handle the case where we conclude a expression which we speculatively
// considered to be unevaluated is actually evaluated.
class TransformToPE : public TreeTransform<TransformToPE> {
  typedef TreeTransform<TransformToPE> BaseTransform;

public:
  TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { }

  // Make sure we redo semantic analysis
  bool AlwaysRebuild() { return true; }
  bool ReplacingOriginal() { return true; }

  // We need to special-case DeclRefExprs referring to FieldDecls which
  // are not part of a member pointer formation; normal TreeTransforming
  // doesn't catch this case because of the way we represent them in the AST.
  // FIXME: This is a bit ugly; is it really the best way to handle this
  // case?
  //
  // Error on DeclRefExprs referring to FieldDecls.
  ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
    if (isa<FieldDecl>(E->getDecl()) &&
        !SemaRef.isUnevaluatedContext())
      return SemaRef.Diag(E->getLocation(),
                          diag::err_invalid_non_static_member_use)
          << E->getDecl() << E->getSourceRange();

    return BaseTransform::TransformDeclRefExpr(E);
  }

  // Exception: filter out member pointer formation
  ExprResult TransformUnaryOperator(UnaryOperator *E) {
    if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
      return E;

    return BaseTransform::TransformUnaryOperator(E);
  }

  // The body of a lambda-expression is in a separate expression evaluation
  // context so never needs to be transformed.
  // FIXME: Ideally we wouldn't transform the closure type either, and would
  // just recreate the capture expressions and lambda expression.
  StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
    return SkipLambdaBody(E, Body);
  }
};
17811}

17813ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
assert(isUnevaluatedContext() &&(static_cast <bool> (isUnevaluatedContext() && "Should only transform unevaluated expressions"
) ? void (0) : __assert_fail ("isUnevaluatedContext() && \"Should only transform unevaluated expressions\""
, "clang/lib/Sema/SemaExpr.cpp", 17815, __extension__ __PRETTY_FUNCTION__
))
       "Should only transform unevaluated expressions")(static_cast <bool> (isUnevaluatedContext() && "Should only transform unevaluated expressions"
) ? void (0) : __assert_fail ("isUnevaluatedContext() && \"Should only transform unevaluated expressions\""
, "clang/lib/Sema/SemaExpr.cpp", 17815, __extension__ __PRETTY_FUNCTION__
));
ExprEvalContexts.back().Context =
    ExprEvalContexts[ExprEvalContexts.size()-2].Context;
if (isUnevaluatedContext())
  return E;
return TransformToPE(*this).TransformExpr(E);
17821}

17823TypeSourceInfo *Sema::TransformToPotentiallyEvaluated(TypeSourceInfo *TInfo) {
assert(isUnevaluatedContext() &&(static_cast <bool> (isUnevaluatedContext() && "Should only transform unevaluated expressions"
) ? void (0) : __assert_fail ("isUnevaluatedContext() && \"Should only transform unevaluated expressions\""
, "clang/lib/Sema/SemaExpr.cpp", 17825, __extension__ __PRETTY_FUNCTION__
))
       "Should only transform unevaluated expressions")(static_cast <bool> (isUnevaluatedContext() && "Should only transform unevaluated expressions"
) ? void (0) : __assert_fail ("isUnevaluatedContext() && \"Should only transform unevaluated expressions\""
, "clang/lib/Sema/SemaExpr.cpp", 17825, __extension__ __PRETTY_FUNCTION__
));
ExprEvalContexts.back().Context =
    ExprEvalContexts[ExprEvalContexts.size() - 2].Context;
if (isUnevaluatedContext())
  return TInfo;
return TransformToPE(*this).TransformType(TInfo);
17831}

17833void
17834Sema::PushExpressionEvaluationContext(
  ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl,
  ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(), Cleanup,
                              LambdaContextDecl, ExprContext);

// Discarded statements and immediate contexts nested in other
// discarded statements or immediate context are themselves
// a discarded statement or an immediate context, respectively.
ExprEvalContexts.back().InDiscardedStatement =
    ExprEvalContexts[ExprEvalContexts.size() - 2]
        .isDiscardedStatementContext();
ExprEvalContexts.back().InImmediateFunctionContext =
    ExprEvalContexts[ExprEvalContexts.size() - 2]
        .isImmediateFunctionContext();

Cleanup.reset();
if (!MaybeODRUseExprs.empty())
  std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
17853}

17855void
17856Sema::PushExpressionEvaluationContext(
  ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
  ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
PushExpressionEvaluationContext(NewContext, ClosureContextDecl, ExprContext);
17861}

17863namespace {

17865const DeclRefExpr *CheckPossibleDeref(Sema &S, const Expr *PossibleDeref) {
PossibleDeref = PossibleDeref->IgnoreParenImpCasts();
if (const auto *E = dyn_cast<UnaryOperator>(PossibleDeref)) {
  if (E->getOpcode() == UO_Deref)
    return CheckPossibleDeref(S, E->getSubExpr());
} else if (const auto *E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
  return CheckPossibleDeref(S, E->getBase());
} else if (const auto *E = dyn_cast<MemberExpr>(PossibleDeref)) {
  return CheckPossibleDeref(S, E->getBase());
} else if (const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
  QualType Inner;
  QualType Ty = E->getType();
  if (const auto *Ptr = Ty->getAs<PointerType>())
    Inner = Ptr->getPointeeType();
  else if (const auto *Arr = S.Context.getAsArrayType(Ty))
    Inner = Arr->getElementType();
  else
    return nullptr;

  if (Inner->hasAttr(attr::NoDeref))
    return E;
}
return nullptr;
17888}

17890} // namespace

17892void Sema::WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec) {
for (const Expr *E : Rec.PossibleDerefs) {
  const DeclRefExpr *DeclRef = CheckPossibleDeref(*this, E);
  if (DeclRef) {
    const ValueDecl *Decl = DeclRef->getDecl();
    Diag(E->getExprLoc(), diag::warn_dereference_of_noderef_type)
        << Decl->getName() << E->getSourceRange();
    Diag(Decl->getLocation(), diag::note_previous_decl) << Decl->getName();
  } else {
    Diag(E->getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
        << E->getSourceRange();
  }
}
Rec.PossibleDerefs.clear();
17906}

17908/// Check whether E, which is either a discarded-value expression or an
17909/// unevaluated operand, is a simple-assignment to a volatlie-qualified lvalue,
17910/// and if so, remove it from the list of volatile-qualified assignments that
17911/// we are going to warn are deprecated.
17912void Sema::CheckUnusedVolatileAssignment(Expr *E) {
if (!E->getType().isVolatileQualified() || !getLangOpts().CPlusPlus20)
  return;

// Note: ignoring parens here is not justified by the standard rules, but
// ignoring parentheses seems like a more reasonable approach, and this only
// drives a deprecation warning so doesn't affect conformance.
if (auto *BO = dyn_cast<BinaryOperator>(E->IgnoreParenImpCasts())) {
  if (BO->getOpcode() == BO_Assign) {
    auto &LHSs = ExprEvalContexts.back().VolatileAssignmentLHSs;
    llvm::erase_value(LHSs, BO->getLHS());
  }
}
17925}

17927ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
if (isUnevaluatedContext() || !E.isUsable() || !Decl ||
    !Decl->isConsteval() || isConstantEvaluated() ||
    isCheckingDefaultArgumentOrInitializer() ||
    RebuildingImmediateInvocation || isImmediateFunctionContext())
  return E;

/// Opportunistically remove the callee from ReferencesToConsteval if we can.
/// It's OK if this fails; we'll also remove this in
/// HandleImmediateInvocations, but catching it here allows us to avoid
/// walking the AST looking for it in simple cases.
if (auto *Call = dyn_cast<CallExpr>(E.get()->IgnoreImplicit()))
  if (auto *DeclRef =
          dyn_cast<DeclRefExpr>(Call->getCallee()->IgnoreImplicit()))
    ExprEvalContexts.back().ReferenceToConsteval.erase(DeclRef);

E = MaybeCreateExprWithCleanups(E);

ConstantExpr *Res = ConstantExpr::Create(
    getASTContext(), E.get(),
    ConstantExpr::getStorageKind(Decl->getReturnType().getTypePtr(),
                                 getASTContext()),
    /*IsImmediateInvocation*/ true);
/// Value-dependent constant expressions should not be immediately
/// evaluated until they are instantiated.
if (!Res->isValueDependent())
  ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
return Res;
17955}

17957static void EvaluateAndDiagnoseImmediateInvocation(
  Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate) {
llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
Expr::EvalResult Eval;
Eval.Diag = &Notes;
ConstantExpr *CE = Candidate.getPointer();
bool Result = CE->EvaluateAsConstantExpr(
    Eval, SemaRef.getASTContext(), ConstantExprKind::ImmediateInvocation);
if (!Result || !Notes.empty()) {
  SemaRef.FailedImmediateInvocations.insert(CE);
  Expr *InnerExpr = CE->getSubExpr()->IgnoreImplicit();
  if (auto *FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))
    InnerExpr = FunctionalCast->getSubExpr();
  FunctionDecl *FD = nullptr;
  if (auto *Call = dyn_cast<CallExpr>(InnerExpr))
    FD = cast<FunctionDecl>(Call->getCalleeDecl());
  else if (auto *Call = dyn_cast<CXXConstructExpr>(InnerExpr))
    FD = Call->getConstructor();
  else
    llvm_unreachable("unhandled decl kind")::llvm::llvm_unreachable_internal("unhandled decl kind", "clang/lib/Sema/SemaExpr.cpp"
, 17976);
  assert(FD && FD->isConsteval())(static_cast <bool> (FD && FD->isConsteval()
) ? void (0) : __assert_fail ("FD && FD->isConsteval()"
, "clang/lib/Sema/SemaExpr.cpp", 17977, __extension__ __PRETTY_FUNCTION__
));
  SemaRef.Diag(CE->getBeginLoc(), diag::err_invalid_consteval_call) << FD;
  if (auto Context =
          SemaRef.InnermostDeclarationWithDelayedImmediateInvocations()) {
    SemaRef.Diag(Context->Loc, diag::note_invalid_consteval_initializer)
        << Context->Decl;
    SemaRef.Diag(Context->Decl->getBeginLoc(), diag::note_declared_at);
  }
  for (auto &Note : Notes)
    SemaRef.Diag(Note.first, Note.second);
  return;
}
CE->MoveIntoResult(Eval.Val, SemaRef.getASTContext());
17990}

17992static void RemoveNestedImmediateInvocation(
  Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec,
  SmallVector<Sema::ImmediateInvocationCandidate, 4>::reverse_iterator It) {
struct ComplexRemove : TreeTransform<ComplexRemove> {
  using Base = TreeTransform<ComplexRemove>;
  llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
  SmallVector<Sema::ImmediateInvocationCandidate, 4> &IISet;
  SmallVector<Sema::ImmediateInvocationCandidate, 4>::reverse_iterator
      CurrentII;
  ComplexRemove(Sema &SemaRef, llvm::SmallPtrSetImpl<DeclRefExpr *> &DR,
                SmallVector<Sema::ImmediateInvocationCandidate, 4> &II,
                SmallVector<Sema::ImmediateInvocationCandidate,
                            4>::reverse_iterator Current)
      : Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
  void RemoveImmediateInvocation(ConstantExpr* E) {
    auto It = std::find_if(CurrentII, IISet.rend(),
                           [E](Sema::ImmediateInvocationCandidate Elem) {
                             return Elem.getPointer() == E;
                           });
    // It is possible that some subexpression of the current immediate
    // invocation was handled from another expression evaluation context. Do
    // not handle the current immediate invocation if some of its
    // subexpressions failed before.
    if (It == IISet.rend()) {
      if (SemaRef.FailedImmediateInvocations.contains(E))
        CurrentII->setInt(1);
    } else {
      It->setInt(1); // Mark as deleted
    }
  }
  ExprResult TransformConstantExpr(ConstantExpr *E) {
    if (!E->isImmediateInvocation())
      return Base::TransformConstantExpr(E);
    RemoveImmediateInvocation(E);
    return Base::TransformExpr(E->getSubExpr());
  }
  /// Base::TransfromCXXOperatorCallExpr doesn't traverse the callee so
  /// we need to remove its DeclRefExpr from the DRSet.
  ExprResult TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
    DRSet.erase(cast<DeclRefExpr>(E->getCallee()->IgnoreImplicit()));
1
The object is a 'CastReturnType'→
    return Base::TransformCXXOperatorCallExpr(E);
2
←
Calling 'TreeTransform::TransformCXXOperatorCallExpr'→
  }
  /// Base::TransformInitializer skip ConstantExpr so we need to visit them
  /// here.
  ExprResult TransformInitializer(Expr *Init, bool NotCopyInit) {
    if (!Init)
      return Init;
    /// ConstantExpr are the first layer of implicit node to be removed so if
    /// Init isn't a ConstantExpr, no ConstantExpr will be skipped.
    if (auto *CE = dyn_cast<ConstantExpr>(Init))
      if (CE->isImmediateInvocation())
        RemoveImmediateInvocation(CE);
    return Base::TransformInitializer(Init, NotCopyInit);
  }
  ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
    DRSet.erase(E);
    return E;
  }
  ExprResult TransformLambdaExpr(LambdaExpr *E) {
    // Do not rebuild lambdas to avoid creating a new type.
    // Lambdas have already been processed inside their eval context.
    return E;
  }
  bool AlwaysRebuild() { return false; }
  bool ReplacingOriginal() { return true; }
  bool AllowSkippingCXXConstructExpr() {
    bool Res = AllowSkippingFirstCXXConstructExpr;
    AllowSkippingFirstCXXConstructExpr = true;
    return Res;
  }
  bool AllowSkippingFirstCXXConstructExpr = true;
} Transformer(SemaRef, Rec.ReferenceToConsteval,
              Rec.ImmediateInvocationCandidates, It);

/// CXXConstructExpr with a single argument are getting skipped by
/// TreeTransform in some situtation because they could be implicit. This
/// can only occur for the top-level CXXConstructExpr because it is used
/// nowhere in the expression being transformed therefore will not be rebuilt.
/// Setting AllowSkippingFirstCXXConstructExpr to false will prevent from
/// skipping the first CXXConstructExpr.
if (isa<CXXConstructExpr>(It->getPointer()->IgnoreImplicit()))
  Transformer.AllowSkippingFirstCXXConstructExpr = false;

ExprResult Res = Transformer.TransformExpr(It->getPointer()->getSubExpr());
// The result may not be usable in case of previous compilation errors.
// In this case evaluation of the expression may result in crash so just
// don't do anything further with the result.
if (Res.isUsable()) {
  Res = SemaRef.MaybeCreateExprWithCleanups(Res);
  It->getPointer()->setSubExpr(Res.get());
}
18083}

18085static void
18086HandleImmediateInvocations(Sema &SemaRef,
                         Sema::ExpressionEvaluationContextRecord &Rec) {
if ((Rec.ImmediateInvocationCandidates.size() == 0 &&
     Rec.ReferenceToConsteval.size() == 0) ||
    SemaRef.RebuildingImmediateInvocation)
  return;

/// When we have more than 1 ImmediateInvocationCandidates or previously
/// failed immediate invocations, we need to check for nested
/// ImmediateInvocationCandidates in order to avoid duplicate diagnostics.
/// Otherwise we only need to remove ReferenceToConsteval in the immediate
/// invocation.
if (Rec.ImmediateInvocationCandidates.size() > 1 ||
    !SemaRef.FailedImmediateInvocations.empty()) {

  /// Prevent sema calls during the tree transform from adding pointers that
  /// are already in the sets.
  llvm::SaveAndRestore DisableIITracking(
      SemaRef.RebuildingImmediateInvocation, true);

  /// Prevent diagnostic during tree transfrom as they are duplicates
  Sema::TentativeAnalysisScope DisableDiag(SemaRef);

  for (auto It = Rec.ImmediateInvocationCandidates.rbegin();
       It != Rec.ImmediateInvocationCandidates.rend(); It++)
    if (!It->getInt())
      RemoveNestedImmediateInvocation(SemaRef, Rec, It);
} else if (Rec.ImmediateInvocationCandidates.size() == 1 &&
           Rec.ReferenceToConsteval.size()) {
  struct SimpleRemove : RecursiveASTVisitor<SimpleRemove> {
    llvm::SmallPtrSetImpl<DeclRefExpr *> &DRSet;
    SimpleRemove(llvm::SmallPtrSetImpl<DeclRefExpr *> &S) : DRSet(S) {}
    bool VisitDeclRefExpr(DeclRefExpr *E) {
      DRSet.erase(E);
      return DRSet.size();
    }
  } Visitor(Rec.ReferenceToConsteval);
  Visitor.TraverseStmt(
      Rec.ImmediateInvocationCandidates.front().getPointer()->getSubExpr());
}
for (auto CE : Rec.ImmediateInvocationCandidates)
  if (!CE.getInt())
    EvaluateAndDiagnoseImmediateInvocation(SemaRef, CE);
for (auto *DR : Rec.ReferenceToConsteval) {
  NamedDecl *ND = cast<FunctionDecl>(DR->getDecl());
  if (auto *MD = llvm::dyn_cast<CXXMethodDecl>(ND);
      MD && (MD->isLambdaStaticInvoker() || isLambdaCallOperator(MD)))
    ND = MD->getParent();
  SemaRef.Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
      << ND << isa<CXXRecordDecl>(ND);
  SemaRef.Diag(ND->getLocation(), diag::note_declared_at);
}
18138}

18140void Sema::PopExpressionEvaluationContext() {
ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
unsigned NumTypos = Rec.NumTypos;

if (!Rec.Lambdas.empty()) {
  using ExpressionKind = ExpressionEvaluationContextRecord::ExpressionKind;
  if (!getLangOpts().CPlusPlus20 &&
      (Rec.ExprContext == ExpressionKind::EK_TemplateArgument ||
       Rec.isUnevaluated() ||
       (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17))) {
    unsigned D;
    if (Rec.isUnevaluated()) {
      // C++11 [expr.prim.lambda]p2:
      //   A lambda-expression shall not appear in an unevaluated operand
      //   (Clause 5).
      D = diag::err_lambda_unevaluated_operand;
    } else if (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17) {
      // C++1y [expr.const]p2:
      //   A conditional-expression e is a core constant expression unless the
      //   evaluation of e, following the rules of the abstract machine, would
      //   evaluate [...] a lambda-expression.
      D = diag::err_lambda_in_constant_expression;
    } else if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument) {
      // C++17 [expr.prim.lamda]p2:
      // A lambda-expression shall not appear [...] in a template-argument.
      D = diag::err_lambda_in_invalid_context;
    } else
      llvm_unreachable("Couldn't infer lambda error message.")::llvm::llvm_unreachable_internal("Couldn't infer lambda error message."
, "clang/lib/Sema/SemaExpr.cpp", 18167);

    for (const auto *L : Rec.Lambdas)
      Diag(L->getBeginLoc(), D);
  }
}

WarnOnPendingNoDerefs(Rec);
HandleImmediateInvocations(*this, Rec);

// Warn on any volatile-qualified simple-assignments that are not discarded-
// value expressions nor unevaluated operands (those cases get removed from
// this list by CheckUnusedVolatileAssignment).
for (auto *BO : Rec.VolatileAssignmentLHSs)
  Diag(BO->getBeginLoc(), diag::warn_deprecated_simple_assign_volatile)
      << BO->getType();

// When are coming out of an unevaluated context, clear out any
// temporaries that we may have created as part of the evaluation of
// the expression in that context: they aren't relevant because they
// will never be constructed.
if (Rec.isUnevaluated() || Rec.isConstantEvaluated()) {
  ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects,
                           ExprCleanupObjects.end());
  Cleanup = Rec.ParentCleanup;
  CleanupVarDeclMarking();
  std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
// Otherwise, merge the contexts together.
} else {
  Cleanup.mergeFrom(Rec.ParentCleanup);
  MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(),
                          Rec.SavedMaybeODRUseExprs.end());
}

// Pop the current expression evaluation context off the stack.
ExprEvalContexts.pop_back();

// The global expression evaluation context record is never popped.
ExprEvalContexts.back().NumTypos += NumTypos;
18206}

18208void Sema::DiscardCleanupsInEvaluationContext() {
ExprCleanupObjects.erase(
       ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
       ExprCleanupObjects.end());
Cleanup.reset();
MaybeODRUseExprs.clear();
18214}

18216ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) {
ExprResult Result = CheckPlaceholderExpr(E);
if (Result.isInvalid())
  return ExprError();
E = Result.get();
if (!E->getType()->isVariablyModifiedType())
  return E;
return TransformToPotentiallyEvaluated(E);
18224}

18226/// Are we in a context that is potentially constant evaluated per C++20
18227/// [expr.const]p12?
18228static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef) {
/// C++2a [expr.const]p12:
//   An expression or conversion is potentially constant evaluated if it is
switch (SemaRef.ExprEvalContexts.back().Context) {
  case Sema::ExpressionEvaluationContext::ConstantEvaluated:
  case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:

    // -- a manifestly constant-evaluated expression,
  case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
  case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
  case Sema::ExpressionEvaluationContext::DiscardedStatement:
    // -- a potentially-evaluated expression,
  case Sema::ExpressionEvaluationContext::UnevaluatedList:
    // -- an immediate subexpression of a braced-init-list,

    // -- [FIXME] an expression of the form & cast-expression that occurs
    //    within a templated entity
    // -- a subexpression of one of the above that is not a subexpression of
    // a nested unevaluated operand.
    return true;

  case Sema::ExpressionEvaluationContext::Unevaluated:
  case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
    // Expressions in this context are never evaluated.
    return false;
}
llvm_unreachable("Invalid context")::llvm::llvm_unreachable_internal("Invalid context", "clang/lib/Sema/SemaExpr.cpp"
, 18254);
18255}

18257/// Return true if this function has a calling convention that requires mangling
18258/// in the size of the parameter pack.
18259static bool funcHasParameterSizeMangling(Sema &S, FunctionDecl *FD) {
// These manglings don't do anything on non-Windows or non-x86 platforms, so
// we don't need parameter type sizes.
const llvm::Triple &TT = S.Context.getTargetInfo().getTriple();
if (!TT.isOSWindows() || !TT.isX86())
  return false;

// If this is C++ and this isn't an extern "C" function, parameters do not
// need to be complete. In this case, C++ mangling will apply, which doesn't
// use the size of the parameters.
if (S.getLangOpts().CPlusPlus && !FD->isExternC())
  return false;

// Stdcall, fastcall, and vectorcall need this special treatment.
CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
switch (CC) {
case CC_X86StdCall:
case CC_X86FastCall:
case CC_X86VectorCall:
  return true;
default:
  break;
}
return false;
18283}

18285/// Require that all of the parameter types of function be complete. Normally,
18286/// parameter types are only required to be complete when a function is called
18287/// or defined, but to mangle functions with certain calling conventions, the
18288/// mangler needs to know the size of the parameter list. In this situation,
18289/// MSVC doesn't emit an error or instantiate templates. Instead, MSVC mangles
18290/// the function as _foo@0, i.e. zero bytes of parameters, which will usually
18291/// result in a linker error. Clang doesn't implement this behavior, and instead
18292/// attempts to error at compile time.
18293static void CheckCompleteParameterTypesForMangler(Sema &S, FunctionDecl *FD,
                                                SourceLocation Loc) {
class ParamIncompleteTypeDiagnoser : public Sema::TypeDiagnoser {
  FunctionDecl *FD;
  ParmVarDecl *Param;

public:
  ParamIncompleteTypeDiagnoser(FunctionDecl *FD, ParmVarDecl *Param)
      : FD(FD), Param(Param) {}

  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
    CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
    StringRef CCName;
    switch (CC) {
    case CC_X86StdCall:
      CCName = "stdcall";
      break;
    case CC_X86FastCall:
      CCName = "fastcall";
      break;
    case CC_X86VectorCall:
      CCName = "vectorcall";
      break;
    default:
      llvm_unreachable("CC does not need mangling")::llvm::llvm_unreachable_internal("CC does not need mangling"
, "clang/lib/Sema/SemaExpr.cpp", 18317);
    }

    S.Diag(Loc, diag::err_cconv_incomplete_param_type)
        << Param->getDeclName() << FD->getDeclName() << CCName;
  }
};

for (ParmVarDecl *Param : FD->parameters()) {
  ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
  S.RequireCompleteType(Loc, Param->getType(), Diagnoser);
}
18329}

18331namespace {
18332enum class OdrUseContext {
/// Declarations in this context are not odr-used.
None,
/// Declarations in this context are formally odr-used, but this is a
/// dependent context.
Dependent,
/// Declarations in this context are odr-used but not actually used (yet).
FormallyOdrUsed,
/// Declarations in this context are used.
Used
18342};
18343}

18345/// Are we within a context in which references to resolved functions or to
18346/// variables result in odr-use?
18347static OdrUseContext isOdrUseContext(Sema &SemaRef) {
OdrUseContext Result;

switch (SemaRef.ExprEvalContexts.back().Context) {
  case Sema::ExpressionEvaluationContext::Unevaluated:
  case Sema::ExpressionEvaluationContext::UnevaluatedList:
  case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
    return OdrUseContext::None;

  case Sema::ExpressionEvaluationContext::ConstantEvaluated:
  case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
  case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
    Result = OdrUseContext::Used;
    break;

  case Sema::ExpressionEvaluationContext::DiscardedStatement:
    Result = OdrUseContext::FormallyOdrUsed;
    break;

  case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
    // A default argument formally results in odr-use, but doesn't actually
    // result in a use in any real sense until it itself is used.
    Result = OdrUseContext::FormallyOdrUsed;
    break;
}

if (SemaRef.CurContext->isDependentContext())
  return OdrUseContext::Dependent;

return Result;
18377}

18379static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func) {
if (!Func->isConstexpr())
  return false;

if (Func->isImplicitlyInstantiable() || !Func->isUserProvided())
  return true;
auto *CCD = dyn_cast<CXXConstructorDecl>(Func);
return CCD && CCD->getInheritedConstructor();
18387}

18389/// Mark a function referenced, and check whether it is odr-used
18390/// (C++ [basic.def.odr]p2, C99 6.9p3)
18391void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
                                bool MightBeOdrUse) {
assert(Func && "No function?")(static_cast <bool> (Func && "No function?") ? void
 (0) : __assert_fail ("Func && \"No function?\"", "clang/lib/Sema/SemaExpr.cpp"
, 18393, __extension__ __PRETTY_FUNCTION__));

Func->setReferenced();

// Recursive functions aren't really used until they're used from some other
// context.
bool IsRecursiveCall = CurContext == Func;

// C++11 [basic.def.odr]p3:
//   A function whose name appears as a potentially-evaluated expression is
//   odr-used if it is the unique lookup result or the selected member of a
//   set of overloaded functions [...].
//
// We (incorrectly) mark overload resolution as an unevaluated context, so we
// can just check that here.
OdrUseContext OdrUse =
    MightBeOdrUse ? isOdrUseContext(*this) : OdrUseContext::None;
if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
  OdrUse = OdrUseContext::FormallyOdrUsed;

// Trivial default constructors and destructors are never actually used.
// FIXME: What about other special members?
if (Func->isTrivial() && !Func->hasAttr<DLLExportAttr>() &&
    OdrUse == OdrUseContext::Used) {
  if (auto *Constructor = dyn_cast<CXXConstructorDecl>(Func))
    if (Constructor->isDefaultConstructor())
      OdrUse = OdrUseContext::FormallyOdrUsed;
  if (isa<CXXDestructorDecl>(Func))
    OdrUse = OdrUseContext::FormallyOdrUsed;
}

// C++20 [expr.const]p12:
//   A function [...] is needed for constant evaluation if it is [...] a
//   constexpr function that is named by an expression that is potentially
//   constant evaluated
bool NeededForConstantEvaluation =
    isPotentiallyConstantEvaluatedContext(*this) &&
    isImplicitlyDefinableConstexprFunction(Func);

// Determine whether we require a function definition to exist, per
// C++11 [temp.inst]p3:
//   Unless a function template specialization has been explicitly
//   instantiated or explicitly specialized, the function template
//   specialization is implicitly instantiated when the specialization is
//   referenced in a context that requires a function definition to exist.
// C++20 [temp.inst]p7:
//   The existence of a definition of a [...] function is considered to
//   affect the semantics of the program if the [...] function is needed for
//   constant evaluation by an expression
// C++20 [basic.def.odr]p10:
//   Every program shall contain exactly one definition of every non-inline
//   function or variable that is odr-used in that program outside of a
//   discarded statement
// C++20 [special]p1:
//   The implementation will implicitly define [defaulted special members]
//   if they are odr-used or needed for constant evaluation.
//
// Note that we skip the implicit instantiation of templates that are only
// used in unused default arguments or by recursive calls to themselves.
// This is formally non-conforming, but seems reasonable in practice.
bool NeedDefinition = !IsRecursiveCall && (OdrUse == OdrUseContext::Used ||
                                           NeededForConstantEvaluation);

// C++14 [temp.expl.spec]p6:
//   If a 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
if (NeedDefinition &&
    (Func->getTemplateSpecializationKind() != TSK_Undeclared ||
     Func->getMemberSpecializationInfo()))
  checkSpecializationReachability(Loc, Func);

if (getLangOpts().CUDA)
  CheckCUDACall(Loc, Func);

// If we need a definition, try to create one.
if (NeedDefinition && !Func->getBody()) {
  runWithSufficientStackSpace(Loc, [&] {
    if (CXXConstructorDecl *Constructor =
            dyn_cast<CXXConstructorDecl>(Func)) {
      Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
      if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
        if (Constructor->isDefaultConstructor()) {
          if (Constructor->isTrivial() &&
              !Constructor->hasAttr<DLLExportAttr>())
            return;
          DefineImplicitDefaultConstructor(Loc, Constructor);
        } else if (Constructor->isCopyConstructor()) {
          DefineImplicitCopyConstructor(Loc, Constructor);
        } else if (Constructor->isMoveConstructor()) {
          DefineImplicitMoveConstructor(Loc, Constructor);
        }
      } else if (Constructor->getInheritedConstructor()) {
        DefineInheritingConstructor(Loc, Constructor);
      }
    } else if (CXXDestructorDecl *Destructor =
                   dyn_cast<CXXDestructorDecl>(Func)) {
      Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
      if (Destructor->isDefaulted() && !Destructor->isDeleted()) {
        if (Destructor->isTrivial() && !Destructor->hasAttr<DLLExportAttr>())
          return;
        DefineImplicitDestructor(Loc, Destructor);
      }
      if (Destructor->isVirtual() && getLangOpts().AppleKext)
        MarkVTableUsed(Loc, Destructor->getParent());
    } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Func)) {
      if (MethodDecl->isOverloadedOperator() &&
          MethodDecl->getOverloadedOperator() == OO_Equal) {
        MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
        if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
          if (MethodDecl->isCopyAssignmentOperator())
            DefineImplicitCopyAssignment(Loc, MethodDecl);
          else if (MethodDecl->isMoveAssignmentOperator())
            DefineImplicitMoveAssignment(Loc, MethodDecl);
        }
      } else if (isa<CXXConversionDecl>(MethodDecl) &&
                 MethodDecl->getParent()->isLambda()) {
        CXXConversionDecl *Conversion =
            cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
        if (Conversion->isLambdaToBlockPointerConversion())
          DefineImplicitLambdaToBlockPointerConversion(Loc, Conversion);
        else
          DefineImplicitLambdaToFunctionPointerConversion(Loc, Conversion);
      } else if (MethodDecl->isVirtual() && getLangOpts().AppleKext)
        MarkVTableUsed(Loc, MethodDecl->getParent());
    }

    if (Func->isDefaulted() && !Func->isDeleted()) {
      DefaultedComparisonKind DCK = getDefaultedComparisonKind(Func);
      if (DCK != DefaultedComparisonKind::None)
        DefineDefaultedComparison(Loc, Func, DCK);
    }

    // Implicit instantiation of function templates and member functions of
    // class templates.
    if (Func->isImplicitlyInstantiable()) {
      TemplateSpecializationKind TSK =
          Func->getTemplateSpecializationKindForInstantiation();
      SourceLocation PointOfInstantiation = Func->getPointOfInstantiation();
      bool FirstInstantiation = PointOfInstantiation.isInvalid();
      if (FirstInstantiation) {
        PointOfInstantiation = Loc;
        if (auto *MSI = Func->getMemberSpecializationInfo())
          MSI->setPointOfInstantiation(Loc);
          // FIXME: Notify listener.
        else
          Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
      } else if (TSK != TSK_ImplicitInstantiation) {
        // Use the point of use as the point of instantiation, instead of the
        // point of explicit instantiation (which we track as the actual point
        // of instantiation). This gives better backtraces in diagnostics.
        PointOfInstantiation = Loc;
      }

      if (FirstInstantiation || TSK != TSK_ImplicitInstantiation ||
          Func->isConstexpr()) {
        if (isa<CXXRecordDecl>(Func->getDeclContext()) &&
            cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() &&
            CodeSynthesisContexts.size())
          PendingLocalImplicitInstantiations.push_back(
              std::make_pair(Func, PointOfInstantiation));
        else if (Func->isConstexpr())
          // Do not defer instantiations of constexpr functions, to avoid the
          // expression evaluator needing to call back into Sema if it sees a
          // call to such a function.
          InstantiateFunctionDefinition(PointOfInstantiation, Func);
        else {
          Func->setInstantiationIsPending(true);
          PendingInstantiations.push_back(
              std::make_pair(Func, PointOfInstantiation));
          // Notify the consumer that a function was implicitly instantiated.
          Consumer.HandleCXXImplicitFunctionInstantiation(Func);
        }
      }
    } else {
      // Walk redefinitions, as some of them may be instantiable.
      for (auto *i : Func->redecls()) {
        if (!i->isUsed(false) && i->isImplicitlyInstantiable())
          MarkFunctionReferenced(Loc, i, MightBeOdrUse);
      }
    }
  });
}

// If a constructor was defined in the context of a default parameter
// or of another default member initializer (ie a PotentiallyEvaluatedIfUsed
// context), its initializers may not be referenced yet.
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) {
  for (CXXCtorInitializer *Init : Constructor->inits()) {
    if (Init->isInClassMemberInitializer())
      runWithSufficientStackSpace(Init->getSourceLocation(), [&]() {
        MarkDeclarationsReferencedInExpr(Init->getInit());
      });
  }
}

// C++14 [except.spec]p17:
//   An exception-specification is considered to be needed when:
//   - the function is odr-used or, if it appears in an unevaluated operand,
//     would be odr-used if the expression were potentially-evaluated;
//
// Note, we do this even if MightBeOdrUse is false. That indicates that the
// function is a pure virtual function we're calling, and in that case the
// function was selected by overload resolution and we need to resolve its
// exception specification for a different reason.
const FunctionProtoType *FPT = Func->getType()->getAs<FunctionProtoType>();
if (FPT && isUnresolvedExceptionSpec(FPT->getExceptionSpecType()))
  ResolveExceptionSpec(Loc, FPT);

// If this is the first "real" use, act on that.
if (OdrUse == OdrUseContext::Used && !Func->isUsed(/*CheckUsedAttr=*/false)) {
  // Keep track of used but undefined functions.
  if (!Func->isDefined()) {
    if (mightHaveNonExternalLinkage(Func))
      UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
    else if (Func->getMostRecentDecl()->isInlined() &&
             !LangOpts.GNUInline &&
             !Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
      UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
    else if (isExternalWithNoLinkageType(Func))
      UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
  }

  // Some x86 Windows calling conventions mangle the size of the parameter
  // pack into the name. Computing the size of the parameters requires the
  // parameter types to be complete. Check that now.
  if (funcHasParameterSizeMangling(*this, Func))
    CheckCompleteParameterTypesForMangler(*this, Func, Loc);

  // In the MS C++ ABI, the compiler emits destructor variants where they are
  // used. If the destructor is used here but defined elsewhere, mark the
  // virtual base destructors referenced. If those virtual base destructors
  // are inline, this will ensure they are defined when emitting the complete
  // destructor variant. This checking may be redundant if the destructor is
  // provided later in this TU.
  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
    if (auto *Dtor = dyn_cast<CXXDestructorDecl>(Func)) {
      CXXRecordDecl *Parent = Dtor->getParent();
      if (Parent->getNumVBases() > 0 && !Dtor->getBody())
        CheckCompleteDestructorVariant(Loc, Dtor);
    }
  }

  Func->markUsed(Context);
}
18639}

18641/// Directly mark a variable odr-used. Given a choice, prefer to use
18642/// MarkVariableReferenced since it does additional checks and then
18643/// calls MarkVarDeclODRUsed.
18644/// If the variable must be captured:
18645///  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
18646///  - else capture it in the DeclContext that maps to the
18647///    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
18648static void
18649MarkVarDeclODRUsed(ValueDecl *V, SourceLocation Loc, Sema &SemaRef,
                 const unsigned *const FunctionScopeIndexToStopAt = nullptr) {
// Keep track of used but undefined variables.
// FIXME: We shouldn't suppress this warning for static data members.
VarDecl *Var = V->getPotentiallyDecomposedVarDecl();
assert(Var && "expected a capturable variable")(static_cast <bool> (Var && "expected a capturable variable"
) ? void (0) : __assert_fail ("Var && \"expected a capturable variable\""
, "clang/lib/Sema/SemaExpr.cpp", 18654, __extension__ __PRETTY_FUNCTION__
));

if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly &&
    (!Var->isExternallyVisible() || Var->isInline() ||
     SemaRef.isExternalWithNoLinkageType(Var)) &&
    !(Var->isStaticDataMember() && Var->hasInit())) {
  SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
  if (old.isInvalid())
    old = Loc;
}
QualType CaptureType, DeclRefType;
if (SemaRef.LangOpts.OpenMP)
  SemaRef.tryCaptureOpenMPLambdas(V);
SemaRef.tryCaptureVariable(V, Loc, Sema::TryCapture_Implicit,
                           /*EllipsisLoc*/ SourceLocation(),
                           /*BuildAndDiagnose*/ true, CaptureType,
                           DeclRefType, FunctionScopeIndexToStopAt);

if (SemaRef.LangOpts.CUDA && Var->hasGlobalStorage()) {
  auto *FD = dyn_cast_or_null<FunctionDecl>(SemaRef.CurContext);
  auto VarTarget = SemaRef.IdentifyCUDATarget(Var);
  auto UserTarget = SemaRef.IdentifyCUDATarget(FD);
  if (VarTarget == Sema::CVT_Host &&
      (UserTarget == Sema::CFT_Device || UserTarget == Sema::CFT_HostDevice ||
       UserTarget == Sema::CFT_Global)) {
    // Diagnose ODR-use of host global variables in device functions.
    // Reference of device global variables in host functions is allowed
    // through shadow variables therefore it is not diagnosed.
    if (SemaRef.LangOpts.CUDAIsDevice) {
      SemaRef.targetDiag(Loc, diag::err_ref_bad_target)
          << /*host*/ 2 << /*variable*/ 1 << Var << UserTarget;
      SemaRef.targetDiag(Var->getLocation(),
                         Var->getType().isConstQualified()
                             ? diag::note_cuda_const_var_unpromoted
                             : diag::note_cuda_host_var);
    }
  } else if (VarTarget == Sema::CVT_Device &&
             (UserTarget == Sema::CFT_Host ||
              UserTarget == Sema::CFT_HostDevice)) {
    // Record a CUDA/HIP device side variable if it is ODR-used
    // by host code. This is done conservatively, when the variable is
    // referenced in any of the following contexts:
    //   - a non-function context
    //   - a host function
    //   - a host device function
    // This makes the ODR-use of the device side variable by host code to
    // be visible in the device compilation for the compiler to be able to
    // emit template variables instantiated by host code only and to
    // externalize the static device side variable ODR-used by host code.
    if (!Var->hasExternalStorage())
      SemaRef.getASTContext().CUDADeviceVarODRUsedByHost.insert(Var);
    else if (SemaRef.LangOpts.GPURelocatableDeviceCode)
      SemaRef.getASTContext().CUDAExternalDeviceDeclODRUsedByHost.insert(Var);
  }
}

V->markUsed(SemaRef.Context);
18711}

18713void Sema::MarkCaptureUsedInEnclosingContext(ValueDecl *Capture,
                                           SourceLocation Loc,
                                           unsigned CapturingScopeIndex) {
MarkVarDeclODRUsed(Capture, Loc, *this, &CapturingScopeIndex);
18717}

18719void diagnoseUncapturableValueReferenceOrBinding(Sema &S, SourceLocation loc,
                                               ValueDecl *var) {
DeclContext *VarDC = var->getDeclContext();

//  If the parameter still belongs to the translation unit, then
//  we're actually just using one parameter in the declaration of
//  the next.
if (isa<ParmVarDecl>(var) &&
    isa<TranslationUnitDecl>(VarDC))
  return;

// For C code, don't diagnose about capture if we're not actually in code
// right now; it's impossible to write a non-constant expression outside of
// function context, so we'll get other (more useful) diagnostics later.
//
// For C++, things get a bit more nasty... it would be nice to suppress this
// diagnostic for certain cases like using a local variable in an array bound
// for a member of a local class, but the correct predicate is not obvious.
if (!S.getLangOpts().CPlusPlus && !S.CurContext->isFunctionOrMethod())
  return;

unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
unsigned ContextKind = 3; // unknown
if (isa<CXXMethodDecl>(VarDC) &&
    cast<CXXRecordDecl>(VarDC->getParent())->isLambda()) {
  ContextKind = 2;
} else if (isa<FunctionDecl>(VarDC)) {
  ContextKind = 0;
} else if (isa<BlockDecl>(VarDC)) {
  ContextKind = 1;
}

S.Diag(loc, diag::err_reference_to_local_in_enclosing_context)
  << var << ValueKind << ContextKind << VarDC;
S.Diag(var->getLocation(), diag::note_entity_declared_at)
    << var;

// FIXME: Add additional diagnostic info about class etc. which prevents
// capture.
18758}

18760static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI,
                                               ValueDecl *Var,
                                               bool &SubCapturesAreNested,
                                               QualType &CaptureType,
                                               QualType &DeclRefType) {
// Check whether we've already captured it.
if (CSI->CaptureMap.count(Var)) {
  // If we found a capture, any subcaptures are nested.
  SubCapturesAreNested = true;

  // Retrieve the capture type for this variable.
  CaptureType = CSI->getCapture(Var).getCaptureType();

  // Compute the type of an expression that refers to this variable.
  DeclRefType = CaptureType.getNonReferenceType();

  // Similarly to mutable captures in lambda, all the OpenMP captures by copy
  // are mutable in the sense that user can change their value - they are
  // private instances of the captured declarations.
  const Capture &Cap = CSI->getCapture(Var);
  if (Cap.isCopyCapture() &&
      !(isa<LambdaScopeInfo>(CSI) && cast<LambdaScopeInfo>(CSI)->Mutable) &&
      !(isa<CapturedRegionScopeInfo>(CSI) &&
        cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind == CR_OpenMP))
    DeclRefType.addConst();
  return true;
}
return false;
18788}

18790// Only block literals, captured statements, and lambda expressions can
18791// capture; other scopes don't work.
18792static DeclContext *getParentOfCapturingContextOrNull(DeclContext *DC,
                                                    ValueDecl *Var,
                                                    SourceLocation Loc,
                                                    const bool Diagnose,
                                                    Sema &S) {
if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC) || isLambdaCallOperator(DC))
  return getLambdaAwareParentOfDeclContext(DC);

VarDecl *Underlying = Var->getPotentiallyDecomposedVarDecl();
if (Underlying) {
  if (Underlying->hasLocalStorage() && Diagnose)
    diagnoseUncapturableValueReferenceOrBinding(S, Loc, Var);
}
return nullptr;
18806}

18808// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
18809// certain types of variables (unnamed, variably modified types etc.)
18810// so check for eligibility.
18811static bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var,
                               SourceLocation Loc, const bool Diagnose,
                               Sema &S) {

assert((isa<VarDecl, BindingDecl>(Var)) &&(static_cast <bool> ((isa<VarDecl, BindingDecl>(Var
)) && "Only variables and structured bindings can be captured"
) ? void (0) : __assert_fail ("(isa<VarDecl, BindingDecl>(Var)) && \"Only variables and structured bindings can be captured\""
, "clang/lib/Sema/SemaExpr.cpp", 18816, __extension__ __PRETTY_FUNCTION__
))
       "Only variables and structured bindings can be captured")(static_cast <bool> ((isa<VarDecl, BindingDecl>(Var
)) && "Only variables and structured bindings can be captured"
) ? void (0) : __assert_fail ("(isa<VarDecl, BindingDecl>(Var)) && \"Only variables and structured bindings can be captured\""
, "clang/lib/Sema/SemaExpr.cpp", 18816, __extension__ __PRETTY_FUNCTION__
));

bool IsBlock = isa<BlockScopeInfo>(CSI);
bool IsLambda = isa<LambdaScopeInfo>(CSI);

// Lambdas are not allowed to capture unnamed variables
// (e.g. anonymous unions).
// FIXME: The C++11 rule don't actually state this explicitly, but I'm
// assuming that's the intent.
if (IsLambda && !Var->getDeclName()) {
  if (Diagnose) {
    S.Diag(Loc, diag::err_lambda_capture_anonymous_var);
    S.Diag(Var->getLocation(), diag::note_declared_at);
  }
  return false;
}

// Prohibit variably-modified types in blocks; they're difficult to deal with.
if (Var->getType()->isVariablyModifiedType() && IsBlock) {
  if (Diagnose) {
    S.Diag(Loc, diag::err_ref_vm_type);
    S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
  }
  return false;
}
// Prohibit structs with flexible array members too.
// We cannot capture what is in the tail end of the struct.
if (const RecordType *VTTy = Var->getType()->getAs<RecordType>()) {
  if (VTTy->getDecl()->hasFlexibleArrayMember()) {
    if (Diagnose) {
      if (IsBlock)
        S.Diag(Loc, diag::err_ref_flexarray_type);
      else
        S.Diag(Loc, diag::err_lambda_capture_flexarray_type) << Var;
      S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
    }
    return false;
  }
}
const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
// Lambdas and captured statements are not allowed to capture __block
// variables; they don't support the expected semantics.
if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
  if (Diagnose) {
    S.Diag(Loc, diag::err_capture_block_variable) << Var << !IsLambda;
    S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
  }
  return false;
}
// OpenCL v2.0 s6.12.5: Blocks cannot reference/capture other blocks
if (S.getLangOpts().OpenCL && IsBlock &&
    Var->getType()->isBlockPointerType()) {
  if (Diagnose)
    S.Diag(Loc, diag::err_opencl_block_ref_block);
  return false;
}

if (isa<BindingDecl>(Var)) {
  if (!IsLambda || !S.getLangOpts().CPlusPlus) {
    if (Diagnose)
      diagnoseUncapturableValueReferenceOrBinding(S, Loc, Var);
    return false;
  } else if (Diagnose && S.getLangOpts().CPlusPlus) {
    S.Diag(Loc, S.LangOpts.CPlusPlus20
                    ? diag::warn_cxx17_compat_capture_binding
                    : diag::ext_capture_binding)
        << Var;
    S.Diag(Var->getLocation(), diag::note_entity_declared_at) << Var;
  }
}

return true;
18888}

18890// Returns true if the capture by block was successful.
18891static bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var,
                         SourceLocation Loc, const bool BuildAndDiagnose,
                         QualType &CaptureType, QualType &DeclRefType,
                         const bool Nested, Sema &S, bool Invalid) {
bool ByRef = false;

// Blocks are not allowed to capture arrays, excepting OpenCL.
// OpenCL v2.0 s1.12.5 (revision 40): arrays are captured by reference
// (decayed to pointers).
if (!Invalid && !S.getLangOpts().OpenCL && CaptureType->isArrayType()) {
  if (BuildAndDiagnose) {
    S.Diag(Loc, diag::err_ref_array_type);
    S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
    Invalid = true;
  } else {
    return false;
  }
}

// Forbid the block-capture of autoreleasing variables.
if (!Invalid &&
    CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
  if (BuildAndDiagnose) {
    S.Diag(Loc, diag::err_arc_autoreleasing_capture)
      << /*block*/ 0;
    S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
    Invalid = true;
  } else {
    return false;
  }
}

// Warn about implicitly autoreleasing indirect parameters captured by blocks.
if (const auto *PT = CaptureType->getAs<PointerType>()) {
  QualType PointeeTy = PT->getPointeeType();

  if (!Invalid && PointeeTy->getAs<ObjCObjectPointerType>() &&
      PointeeTy.getObjCLifetime() == Qualifiers::OCL_Autoreleasing &&
      !S.Context.hasDirectOwnershipQualifier(PointeeTy)) {
    if (BuildAndDiagnose) {
      SourceLocation VarLoc = Var->getLocation();
      S.Diag(Loc, diag::warn_block_capture_autoreleasing);
      S.Diag(VarLoc, diag::note_declare_parameter_strong);
    }
  }
}

const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
if (HasBlocksAttr || CaptureType->isReferenceType() ||
    (S.getLangOpts().OpenMP && S.isOpenMPCapturedDecl(Var))) {
  // Block capture by reference does not change the capture or
  // declaration reference types.
  ByRef = true;
} else {
  // Block capture by copy introduces 'const'.
  CaptureType = CaptureType.getNonReferenceType().withConst();
  DeclRefType = CaptureType;
}

// Actually capture the variable.
if (BuildAndDiagnose)
  BSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc, SourceLocation(),
                  CaptureType, Invalid);

return !Invalid;
18956}

18958/// Capture the given variable in the captured region.
18959static bool captureInCapturedRegion(
  CapturedRegionScopeInfo *RSI, ValueDecl *Var, SourceLocation Loc,
  const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType,
  const bool RefersToCapturedVariable, Sema::TryCaptureKind Kind,
  bool IsTopScope, Sema &S, bool Invalid) {
// By default, capture variables by reference.
bool ByRef = true;
if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
  ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
} else if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP) {
  // Using an LValue reference type is consistent with Lambdas (see below).
  if (S.isOpenMPCapturedDecl(Var)) {
    bool HasConst = DeclRefType.isConstQualified();
    DeclRefType = DeclRefType.getUnqualifiedType();
    // Don't lose diagnostics about assignments to const.
    if (HasConst)
      DeclRefType.addConst();
  }
  // Do not capture firstprivates in tasks.
  if (S.isOpenMPPrivateDecl(Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel) !=
      OMPC_unknown)
    return true;
  ByRef = S.isOpenMPCapturedByRef(Var, RSI->OpenMPLevel,
                                  RSI->OpenMPCaptureLevel);
}

if (ByRef)
  CaptureType = S.Context.getLValueReferenceType(DeclRefType);
else
  CaptureType = DeclRefType;

// Actually capture the variable.
if (BuildAndDiagnose)
  RSI->addCapture(Var, /*isBlock*/ false, ByRef, RefersToCapturedVariable,
                  Loc, SourceLocation(), CaptureType, Invalid);

return !Invalid;
18996}

18998/// Capture the given variable in the lambda.
18999static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
                          SourceLocation Loc, const bool BuildAndDiagnose,
                          QualType &CaptureType, QualType &DeclRefType,
                          const bool RefersToCapturedVariable,
                          const Sema::TryCaptureKind Kind,
                          SourceLocation EllipsisLoc, const bool IsTopScope,
                          Sema &S, bool Invalid) {
// Determine whether we are capturing by reference or by value.
bool ByRef = false;
if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
  ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
} else {
  ByRef = (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
}

BindingDecl *BD = dyn_cast<BindingDecl>(Var);
// FIXME: We should support capturing structured bindings in OpenMP.
if (!Invalid && BD && S.LangOpts.OpenMP) {
  if (BuildAndDiagnose) {
    S.Diag(Loc, diag::err_capture_binding_openmp) << Var;
    S.Diag(Var->getLocation(), diag::note_entity_declared_at) << Var;
  }
  Invalid = true;
}

if (BuildAndDiagnose && S.Context.getTargetInfo().getTriple().isWasm() &&
    CaptureType.getNonReferenceType()->isWebAssemblyReferenceType()) {
  S.Diag(Loc, diag::err_wasm_ca_reference) << 0;
  Invalid = true;
}

// Compute the type of the field that will capture this variable.
if (ByRef) {
  // C++11 [expr.prim.lambda]p15:
  //   An entity is captured by reference if it is implicitly or
  //   explicitly captured but not captured by copy. It is
  //   unspecified whether additional unnamed non-static data
  //   members are declared in the closure type for entities
  //   captured by reference.
  //
  // FIXME: It is not clear whether we want to build an lvalue reference
  // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears
  // to do the former, while EDG does the latter. Core issue 1249 will
  // clarify, but for now we follow GCC because it's a more permissive and
  // easily defensible position.
  CaptureType = S.Context.getLValueReferenceType(DeclRefType);
} else {
  // C++11 [expr.prim.lambda]p14:
  //   For each entity captured by copy, an unnamed non-static
  //   data member is declared in the closure type. The
  //   declaration order of these members is unspecified. The type
  //   of such a data member is the type of the corresponding
  //   captured entity if the entity is not a reference to an
  //   object, or the referenced type otherwise. [Note: If the
  //   captured entity is a reference to a function, the
  //   corresponding data member is also a reference to a
  //   function. - end note ]
  if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){
    if (!RefType->getPointeeType()->isFunctionType())
      CaptureType = RefType->getPointeeType();
  }

  // Forbid the lambda copy-capture of autoreleasing variables.
  if (!Invalid &&
      CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
    if (BuildAndDiagnose) {
      S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
      S.Diag(Var->getLocation(), diag::note_previous_decl)
        << Var->getDeclName();
      Invalid = true;
    } else {
      return false;
    }
  }

  // Make sure that by-copy captures are of a complete and non-abstract type.
  if (!Invalid && BuildAndDiagnose) {
    if (!CaptureType->isDependentType() &&
        S.RequireCompleteSizedType(
            Loc, CaptureType,
            diag::err_capture_of_incomplete_or_sizeless_type,
            Var->getDeclName()))
      Invalid = true;
    else if (S.RequireNonAbstractType(Loc, CaptureType,
                                      diag::err_capture_of_abstract_type))
      Invalid = true;
  }
}

// Compute the type of a reference to this captured variable.
if (ByRef)
  DeclRefType = CaptureType.getNonReferenceType();
else {
  // C++ [expr.prim.lambda]p5:
  //   The closure type for a lambda-expression has a public inline
  //   function call operator [...]. This function call operator is
  //   declared const (9.3.1) if and only if the lambda-expression's
  //   parameter-declaration-clause is not followed by mutable.
  DeclRefType = CaptureType.getNonReferenceType();
  if (!LSI->Mutable && !CaptureType->isReferenceType())
    DeclRefType.addConst();
}

// Add the capture.
if (BuildAndDiagnose)
  LSI->addCapture(Var, /*isBlock=*/false, ByRef, RefersToCapturedVariable,
                  Loc, EllipsisLoc, CaptureType, Invalid);

return !Invalid;
19108}

19110static bool canCaptureVariableByCopy(ValueDecl *Var,
                                   const ASTContext &Context) {
// Offer a Copy fix even if the type is dependent.
if (Var->getType()->isDependentType())
  return true;
QualType T = Var->getType().getNonReferenceType();
if (T.isTriviallyCopyableType(Context))
  return true;
if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {

  if (!(RD = RD->getDefinition()))
    return false;
  if (RD->hasSimpleCopyConstructor())
    return true;
  if (RD->hasUserDeclaredCopyConstructor())
    for (CXXConstructorDecl *Ctor : RD->ctors())
      if (Ctor->isCopyConstructor())
        return !Ctor->isDeleted();
}
return false;
19130}

19132/// Create up to 4 fix-its for explicit reference and value capture of \p Var or
19133/// default capture. Fixes may be omitted if they aren't allowed by the
19134/// standard, for example we can't emit a default copy capture fix-it if we
19135/// already explicitly copy capture capture another variable.
19136static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI,
                                  ValueDecl *Var) {
assert(LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None)(static_cast <bool> (LSI->ImpCaptureStyle == CapturingScopeInfo
::ImpCap_None) ? void (0) : __assert_fail ("LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None"
, "clang/lib/Sema/SemaExpr.cpp", 19138, __extension__ __PRETTY_FUNCTION__
));
// Don't offer Capture by copy of default capture by copy fixes if Var is
// known not to be copy constructible.
bool ShouldOfferCopyFix = canCaptureVariableByCopy(Var, Sema.getASTContext());

SmallString<32> FixBuffer;
StringRef Separator = LSI->NumExplicitCaptures > 0 ? ", " : "";
if (Var->getDeclName().isIdentifier() && !Var->getName().empty()) {
  SourceLocation VarInsertLoc = LSI->IntroducerRange.getEnd();
  if (ShouldOfferCopyFix) {
    // Offer fixes to insert an explicit capture for the variable.
    // [] -> [VarName]
    // [OtherCapture] -> [OtherCapture, VarName]
    FixBuffer.assign({Separator, Var->getName()});
    Sema.Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
        << Var << /*value*/ 0
        << FixItHint::CreateInsertion(VarInsertLoc, FixBuffer);
  }
  // As above but capture by reference.
  FixBuffer.assign({Separator, "&", Var->getName()});
  Sema.Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
      << Var << /*reference*/ 1
      << FixItHint::CreateInsertion(VarInsertLoc, FixBuffer);
}

// Only try to offer default capture if there are no captures excluding this
// and init captures.
// [this]: OK.
// [X = Y]: OK.
// [&A, &B]: Don't offer.
// [A, B]: Don't offer.
if (llvm::any_of(LSI->Captures, [](Capture &C) {
      return !C.isThisCapture() && !C.isInitCapture();
    }))
  return;

// The default capture specifiers, '=' or '&', must appear first in the
// capture body.
SourceLocation DefaultInsertLoc =
    LSI->IntroducerRange.getBegin().getLocWithOffset(1);

if (ShouldOfferCopyFix) {
  bool CanDefaultCopyCapture = true;
  // [=, *this] OK since c++17
  // [=, this] OK since c++20
  if (LSI->isCXXThisCaptured() && !Sema.getLangOpts().CPlusPlus20)
    CanDefaultCopyCapture = Sema.getLangOpts().CPlusPlus17
                                ? LSI->getCXXThisCapture().isCopyCapture()
                                : false;
  // We can't use default capture by copy if any captures already specified
  // capture by copy.
  if (CanDefaultCopyCapture && llvm::none_of(LSI->Captures, [](Capture &C) {
        return !C.isThisCapture() && !C.isInitCapture() && C.isCopyCapture();
      })) {
    FixBuffer.assign({"=", Separator});
    Sema.Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
        << /*value*/ 0
        << FixItHint::CreateInsertion(DefaultInsertLoc, FixBuffer);
  }
}

// We can't use default capture by reference if any captures already specified
// capture by reference.
if (llvm::none_of(LSI->Captures, [](Capture &C) {
      return !C.isInitCapture() && C.isReferenceCapture() &&
             !C.isThisCapture();
    })) {
  FixBuffer.assign({"&", Separator});
  Sema.Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
      << /*reference*/ 1
      << FixItHint::CreateInsertion(DefaultInsertLoc, FixBuffer);
}
19210}

19212bool Sema::tryCaptureVariable(
  ValueDecl *Var, SourceLocation ExprLoc, TryCaptureKind Kind,
  SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType,
  QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt) {
// An init-capture is notionally from the context surrounding its
// declaration, but its parent DC is the lambda class.
DeclContext *VarDC = Var->getDeclContext();
DeclContext *DC = CurContext;

// tryCaptureVariable is called every time a DeclRef is formed,
// it can therefore have non-negigible impact on performances.
// For local variables and when there is no capturing scope,
// we can bailout early.
if (CapturingFunctionScopes == 0 && (!BuildAndDiagnose || VarDC == DC))
  return true;

const auto *VD = dyn_cast<VarDecl>(Var);
if (VD) {
  if (VD->isInitCapture())
    VarDC = VarDC->getParent();
} else {
  VD = Var->getPotentiallyDecomposedVarDecl();
}
assert(VD && "Cannot capture a null variable")(static_cast <bool> (VD && "Cannot capture a null variable"
) ? void (0) : __assert_fail ("VD && \"Cannot capture a null variable\""
, "clang/lib/Sema/SemaExpr.cpp", 19235, __extension__ __PRETTY_FUNCTION__
));

const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
    ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
// We need to sync up the Declaration Context with the
// FunctionScopeIndexToStopAt
if (FunctionScopeIndexToStopAt) {
  unsigned FSIndex = FunctionScopes.size() - 1;
  while (FSIndex != MaxFunctionScopesIndex) {
    DC = getLambdaAwareParentOfDeclContext(DC);
    --FSIndex;
  }
}

// Capture global variables if it is required to use private copy of this
// variable.
bool IsGlobal = !VD->hasLocalStorage();
if (IsGlobal &&
    !(LangOpts.OpenMP && isOpenMPCapturedDecl(Var, /*CheckScopeInfo=*/true,
                                              MaxFunctionScopesIndex)))
  return true;

if (isa<VarDecl>(Var))
  Var = cast<VarDecl>(Var->getCanonicalDecl());

// Walk up the stack to determine whether we can capture the variable,
// performing the "simple" checks that don't depend on type. We stop when
// we've either hit the declared scope of the variable or find an existing
// capture of that variable.  We start from the innermost capturing-entity
// (the DC) and ensure that all intervening capturing-entities
// (blocks/lambdas etc.) between the innermost capturer and the variable`s
// declcontext can either capture the variable or have already captured
// the variable.
CaptureType = Var->getType();
DeclRefType = CaptureType.getNonReferenceType();
bool Nested = false;
bool Explicit = (Kind != TryCapture_Implicit);
unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
do {

  LambdaScopeInfo *LSI = nullptr;
  if (!FunctionScopes.empty())
    LSI = dyn_cast_or_null<LambdaScopeInfo>(
        FunctionScopes[FunctionScopesIndex]);

  bool IsInScopeDeclarationContext =
      !LSI || LSI->AfterParameterList || CurContext == LSI->CallOperator;

  if (LSI && !LSI->AfterParameterList) {
    // This allows capturing parameters from a default value which does not
    // seems correct
    if (isa<ParmVarDecl>(Var) && !Var->getDeclContext()->isFunctionOrMethod())
      return true;
  }
  // If the variable is declared in the current context, there is no need to
  // capture it.
  if (IsInScopeDeclarationContext &&
      FunctionScopesIndex == MaxFunctionScopesIndex && VarDC == DC)
    return true;

  // When evaluating some attributes (like enable_if) we might refer to a
  // function parameter appertaining to the same declaration as that
  // attribute.
  if (const auto *Parm = dyn_cast<ParmVarDecl>(Var);
      Parm && Parm->getDeclContext() == DC)
    return true;

  // Only block literals, captured statements, and lambda expressions can
  // capture; other scopes don't work.
  DeclContext *ParentDC =
      !IsInScopeDeclarationContext
          ? DC->getParent()
          : getParentOfCapturingContextOrNull(DC, Var, ExprLoc,
                                              BuildAndDiagnose, *this);
  // We need to check for the parent *first* because, if we *have*
  // private-captured a global variable, we need to recursively capture it in
  // intermediate blocks, lambdas, etc.
  if (!ParentDC) {
    if (IsGlobal) {
      FunctionScopesIndex = MaxFunctionScopesIndex - 1;
      break;
    }
    return true;
  }

  FunctionScopeInfo  *FSI = FunctionScopes[FunctionScopesIndex];
  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);

  // Check whether we've already captured it.
  if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType,
                                           DeclRefType)) {
    CSI->getCapture(Var).markUsed(BuildAndDiagnose);
    break;
  }
  // If we are instantiating a generic lambda call operator body,
  // we do not want to capture new variables.  What was captured
  // during either a lambdas transformation or initial parsing
  // should be used.
  if (isGenericLambdaCallOperatorSpecialization(DC)) {
    if (BuildAndDiagnose) {
      LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
      if (LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None) {
        Diag(ExprLoc, diag::err_lambda_impcap) << Var;
        Diag(Var->getLocation(), diag::note_previous_decl) << Var;
        Diag(LSI->Lambda->getBeginLoc(), diag::note_lambda_decl);
        buildLambdaCaptureFixit(*this, LSI, Var);
      } else
        diagnoseUncapturableValueReferenceOrBinding(*this, ExprLoc, Var);
    }
    return true;
  }

  // Try to capture variable-length arrays types.
  if (Var->getType()->isVariablyModifiedType()) {
    // We're going to walk down into the type and look for VLA
    // expressions.
    QualType QTy = Var->getType();
    if (ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
      QTy = PVD->getOriginalType();
    captureVariablyModifiedType(Context, QTy, CSI);
  }

  if (getLangOpts().OpenMP) {
    if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
      // OpenMP private variables should not be captured in outer scope, so
      // just break here. Similarly, global variables that are captured in a
      // target region should not be captured outside the scope of the region.
      if (RSI->CapRegionKind == CR_OpenMP) {
        OpenMPClauseKind IsOpenMPPrivateDecl = isOpenMPPrivateDecl(
            Var, RSI->OpenMPLevel, RSI->OpenMPCaptureLevel);
        // If the variable is private (i.e. not captured) and has variably
        // modified type, we still need to capture the type for correct
        // codegen in all regions, associated with the construct. Currently,
        // it is captured in the innermost captured region only.
        if (IsOpenMPPrivateDecl != OMPC_unknown &&
            Var->getType()->isVariablyModifiedType()) {
          QualType QTy = Var->getType();
          if (ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
            QTy = PVD->getOriginalType();
          for (int I = 1, E = getNumberOfConstructScopes(RSI->OpenMPLevel);
               I < E; ++I) {
            auto *OuterRSI = cast<CapturedRegionScopeInfo>(
                FunctionScopes[FunctionScopesIndex - I]);
            assert(RSI->OpenMPLevel == OuterRSI->OpenMPLevel &&(static_cast <bool> (RSI->OpenMPLevel == OuterRSI->
OpenMPLevel && "Wrong number of captured regions associated with the "
 "OpenMP construct.") ? void (0) : __assert_fail ("RSI->OpenMPLevel == OuterRSI->OpenMPLevel && \"Wrong number of captured regions associated with the \" \"OpenMP construct.\""
, "clang/lib/Sema/SemaExpr.cpp", 19380, __extension__ __PRETTY_FUNCTION__
))
                   "Wrong number of captured regions associated with the "(static_cast <bool> (RSI->OpenMPLevel == OuterRSI->
OpenMPLevel && "Wrong number of captured regions associated with the "
 "OpenMP construct.") ? void (0) : __assert_fail ("RSI->OpenMPLevel == OuterRSI->OpenMPLevel && \"Wrong number of captured regions associated with the \" \"OpenMP construct.\""
, "clang/lib/Sema/SemaExpr.cpp", 19380, __extension__ __PRETTY_FUNCTION__
))
                   "OpenMP construct.")(static_cast <bool> (RSI->OpenMPLevel == OuterRSI->
OpenMPLevel && "Wrong number of captured regions associated with the "
 "OpenMP construct.") ? void (0) : __assert_fail ("RSI->OpenMPLevel == OuterRSI->OpenMPLevel && \"Wrong number of captured regions associated with the \" \"OpenMP construct.\""
, "clang/lib/Sema/SemaExpr.cpp", 19380, __extension__ __PRETTY_FUNCTION__
));
            captureVariablyModifiedType(Context, QTy, OuterRSI);
          }
        }
        bool IsTargetCap =
            IsOpenMPPrivateDecl != OMPC_private &&
            isOpenMPTargetCapturedDecl(Var, RSI->OpenMPLevel,
                                       RSI->OpenMPCaptureLevel);
        // Do not capture global if it is not privatized in outer regions.
        bool IsGlobalCap =
            IsGlobal && isOpenMPGlobalCapturedDecl(Var, RSI->OpenMPLevel,
                                                   RSI->OpenMPCaptureLevel);

        // When we detect target captures we are looking from inside the
        // target region, therefore we need to propagate the capture from the
        // enclosing region. Therefore, the capture is not initially nested.
        if (IsTargetCap)
          adjustOpenMPTargetScopeIndex(FunctionScopesIndex, RSI->OpenMPLevel);

        if (IsTargetCap || IsOpenMPPrivateDecl == OMPC_private ||
            (IsGlobal && !IsGlobalCap)) {
          Nested = !IsTargetCap;
          bool HasConst = DeclRefType.isConstQualified();
          DeclRefType = DeclRefType.getUnqualifiedType();
          // Don't lose diagnostics about assignments to const.
          if (HasConst)
            DeclRefType.addConst();
          CaptureType = Context.getLValueReferenceType(DeclRefType);
          break;
        }
      }
    }
  }
  if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) {
    // No capture-default, and this is not an explicit capture
    // so cannot capture this variable.
    if (BuildAndDiagnose) {
      Diag(ExprLoc, diag::err_lambda_impcap) << Var;
      Diag(Var->getLocation(), diag::note_previous_decl) << Var;
      auto *LSI = cast<LambdaScopeInfo>(CSI);
      if (LSI->Lambda) {
        Diag(LSI->Lambda->getBeginLoc(), diag::note_lambda_decl);
        buildLambdaCaptureFixit(*this, LSI, Var);
      }
      // FIXME: If we error out because an outer lambda can not implicitly
      // capture a variable that an inner lambda explicitly captures, we
      // should have the inner lambda do the explicit capture - because
      // it makes for cleaner diagnostics later.  This would purely be done
      // so that the diagnostic does not misleadingly claim that a variable
      // can not be captured by a lambda implicitly even though it is captured
      // explicitly.  Suggestion:
      //  - create const bool VariableCaptureWasInitiallyExplicit = Explicit
      //    at the function head
      //  - cache the StartingDeclContext - this must be a lambda
      //  - captureInLambda in the innermost lambda the variable.
    }
    return true;
  }
  Explicit = false;
  FunctionScopesIndex--;
  if (IsInScopeDeclarationContext)
    DC = ParentDC;
} while (!VarDC->Equals(DC));

// Walk back down the scope stack, (e.g. from outer lambda to inner lambda)
// computing the type of the capture at each step, checking type-specific
// requirements, and adding captures if requested.
// If the variable had already been captured previously, we start capturing
// at the lambda nested within that one.
bool Invalid = false;
for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
     ++I) {
  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]);

  // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
  // certain types of variables (unnamed, variably modified types etc.)
  // so check for eligibility.
  if (!Invalid)
    Invalid =
        !isVariableCapturable(CSI, Var, ExprLoc, BuildAndDiagnose, *this);

  // After encountering an error, if we're actually supposed to capture, keep
  // capturing in nested contexts to suppress any follow-on diagnostics.
  if (Invalid && !BuildAndDiagnose)
    return true;

  if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
    Invalid = !captureInBlock(BSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
                             DeclRefType, Nested, *this, Invalid);
    Nested = true;
  } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
    Invalid = !captureInCapturedRegion(
        RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
        Kind, /*IsTopScope*/ I == N - 1, *this, Invalid);
    Nested = true;
  } else {
    LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
    Invalid =
        !captureInLambda(LSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
                         DeclRefType, Nested, Kind, EllipsisLoc,
                         /*IsTopScope*/ I == N - 1, *this, Invalid);
    Nested = true;
  }

  if (Invalid && !BuildAndDiagnose)
    return true;
}
return Invalid;
19488}

19490bool Sema::tryCaptureVariable(ValueDecl *Var, SourceLocation Loc,
                            TryCaptureKind Kind, SourceLocation EllipsisLoc) {
QualType CaptureType;
QualType DeclRefType;
return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
                          /*BuildAndDiagnose=*/true, CaptureType,
                          DeclRefType, nullptr);
19497}

19499bool Sema::NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc) {
QualType CaptureType;
QualType DeclRefType;
return !tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
                           /*BuildAndDiagnose=*/false, CaptureType,
                           DeclRefType, nullptr);
19505}

19507QualType Sema::getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc) {
QualType CaptureType;
QualType DeclRefType;

// Determine whether we can capture this variable.
if (tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
                       /*BuildAndDiagnose=*/false, CaptureType,
                       DeclRefType, nullptr))
  return QualType();

return DeclRefType;
19518}

19520namespace {
19521// Helper to copy the template arguments from a DeclRefExpr or MemberExpr.
19522// The produced TemplateArgumentListInfo* points to data stored within this
19523// object, so should only be used in contexts where the pointer will not be
19524// used after the CopiedTemplateArgs object is destroyed.
19525class CopiedTemplateArgs {
bool HasArgs;
TemplateArgumentListInfo TemplateArgStorage;
19528public:
template<typename RefExpr>
CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
  if (HasArgs)
    E->copyTemplateArgumentsInto(TemplateArgStorage);
}
operator TemplateArgumentListInfo*()
19535#ifdef __has_cpp_attribute
19536#if0 __has_cpp_attribute(clang::lifetimebound)1
[[clang::lifetimebound]]
19538#endif
19539#endif
{
  return HasArgs ? &TemplateArgStorage : nullptr;
}
19543};
19544}

19546/// Walk the set of potential results of an expression and mark them all as
19547/// non-odr-uses if they satisfy the side-conditions of the NonOdrUseReason.
19548///
19549/// \return A new expression if we found any potential results, ExprEmpty() if
19550///         not, and ExprError() if we diagnosed an error.
19551static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E,
                                                    NonOdrUseReason NOUR) {
// Per C++11 [basic.def.odr], a variable is odr-used "unless it is
// an object that satisfies the requirements for appearing in a
// constant expression (5.19) and the lvalue-to-rvalue conversion (4.1)
// is immediately applied."  This function handles the lvalue-to-rvalue
// conversion part.
//
// If we encounter a node that claims to be an odr-use but shouldn't be, we
// transform it into the relevant kind of non-odr-use node and rebuild the
// tree of nodes leading to it.
//
// This is a mini-TreeTransform that only transforms a restricted subset of
// nodes (and only certain operands of them).

// Rebuild a subexpression.
auto Rebuild = [&](Expr *Sub) {
  return rebuildPotentialResultsAsNonOdrUsed(S, Sub, NOUR);
};

// Check whether a potential result satisfies the requirements of NOUR.
auto IsPotentialResultOdrUsed = [&](NamedDecl *D) {
  // Any entity other than a VarDecl is always odr-used whenever it's named
  // in a potentially-evaluated expression.
  auto *VD = dyn_cast<VarDecl>(D);
  if (!VD)
    return true;

  // C++2a [basic.def.odr]p4:
  //   A variable x whose name appears as a potentially-evalauted expression
  //   e is odr-used by e unless
  //   -- x is a reference that is usable in constant expressions, or
  //   -- x is a variable of non-reference type that is usable in constant
  //      expressions and has no mutable subobjects, and e is an element of
  //      the set of potential results of an expression of
  //      non-volatile-qualified non-class type to which the lvalue-to-rvalue
  //      conversion is applied, or
  //   -- x is a variable of non-reference type, and e is an element of the
  //      set of potential results of a discarded-value expression to which
  //      the lvalue-to-rvalue conversion is not applied
  //
  // We check the first bullet and the "potentially-evaluated" condition in
  // BuildDeclRefExpr. We check the type requirements in the second bullet
  // in CheckLValueToRValueConversionOperand below.
  switch (NOUR) {
  case NOUR_None:
  case NOUR_Unevaluated:
    llvm_unreachable("unexpected non-odr-use-reason")::llvm::llvm_unreachable_internal("unexpected non-odr-use-reason"
, "clang/lib/Sema/SemaExpr.cpp", 19598);

  case NOUR_Constant:
    // Constant references were handled when they were built.
    if (VD->getType()->isReferenceType())
      return true;
    if (auto *RD = VD->getType()->getAsCXXRecordDecl())
      if (RD->hasMutableFields())
        return true;
    if (!VD->isUsableInConstantExpressions(S.Context))
      return true;
    break;

  case NOUR_Discarded:
    if (VD->getType()->isReferenceType())
      return true;
    break;
  }
  return false;
};

// Mark that this expression does not constitute an odr-use.
auto MarkNotOdrUsed = [&] {
  S.MaybeODRUseExprs.remove(E);
  if (LambdaScopeInfo *LSI = S.getCurLambda())
    LSI->markVariableExprAsNonODRUsed(E);
};

// C++2a [basic.def.odr]p2:
//   The set of potential results of an expression e is defined as follows:
switch (E->getStmtClass()) {
//   -- If e is an id-expression, ...
case Expr::DeclRefExprClass: {
  auto *DRE = cast<DeclRefExpr>(E);
  if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
    break;

  // Rebuild as a non-odr-use DeclRefExpr.
  MarkNotOdrUsed();
  return DeclRefExpr::Create(
      S.Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
      DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
      DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
      DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
}

case Expr::FunctionParmPackExprClass: {
  auto *FPPE = cast<FunctionParmPackExpr>(E);
  // If any of the declarations in the pack is odr-used, then the expression
  // as a whole constitutes an odr-use.
  for (VarDecl *D : *FPPE)
    if (IsPotentialResultOdrUsed(D))
      return ExprEmpty();

  // FIXME: Rebuild as a non-odr-use FunctionParmPackExpr? In practice,
  // nothing cares about whether we marked this as an odr-use, but it might
  // be useful for non-compiler tools.
  MarkNotOdrUsed();
  break;
}

//   -- If e is a subscripting operation with an array operand...
case Expr::ArraySubscriptExprClass: {
  auto *ASE = cast<ArraySubscriptExpr>(E);
  Expr *OldBase = ASE->getBase()->IgnoreImplicit();
  if (!OldBase->getType()->isArrayType())
    break;
  ExprResult Base = Rebuild(OldBase);
  if (!Base.isUsable())
    return Base;
  Expr *LHS = ASE->getBase() == ASE->getLHS() ? Base.get() : ASE->getLHS();
  Expr *RHS = ASE->getBase() == ASE->getRHS() ? Base.get() : ASE->getRHS();
  SourceLocation LBracketLoc = ASE->getBeginLoc(); // FIXME: Not stored.
  return S.ActOnArraySubscriptExpr(nullptr, LHS, LBracketLoc, RHS,
                                   ASE->getRBracketLoc());
}

case Expr::MemberExprClass: {
  auto *ME = cast<MemberExpr>(E);
  // -- If e is a class member access expression [...] naming a non-static
  //    data member...
  if (isa<FieldDecl>(ME->getMemberDecl())) {
    ExprResult Base = Rebuild(ME->getBase());
    if (!Base.isUsable())
      return Base;
    return MemberExpr::Create(
        S.Context, Base.get(), ME->isArrow(), ME->getOperatorLoc(),
        ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
        ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
        CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
        ME->getObjectKind(), ME->isNonOdrUse());
  }

  if (ME->getMemberDecl()->isCXXInstanceMember())
    break;

  // -- If e is a class member access expression naming a static data member,
  //    ...
  if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
    break;

  // Rebuild as a non-odr-use MemberExpr.
  MarkNotOdrUsed();
  return MemberExpr::Create(
      S.Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
      ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
      ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
      ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
}

case Expr::BinaryOperatorClass: {
  auto *BO = cast<BinaryOperator>(E);
  Expr *LHS = BO->getLHS();
  Expr *RHS = BO->getRHS();
  // -- If e is a pointer-to-member expression of the form e1 .* e2 ...
  if (BO->getOpcode() == BO_PtrMemD) {
    ExprResult Sub = Rebuild(LHS);
    if (!Sub.isUsable())
      return Sub;
    LHS = Sub.get();
  //   -- If e is a comma expression, ...
  } else if (BO->getOpcode() == BO_Comma) {
    ExprResult Sub = Rebuild(RHS);
    if (!Sub.isUsable())
      return Sub;
    RHS = Sub.get();
  } else {
    break;
  }
  return S.BuildBinOp(nullptr, BO->getOperatorLoc(), BO->getOpcode(),
                      LHS, RHS);
}

//   -- If e has the form (e1)...
case Expr::ParenExprClass: {
  auto *PE = cast<ParenExpr>(E);
  ExprResult Sub = Rebuild(PE->getSubExpr());
  if (!Sub.isUsable())
    return Sub;
  return S.ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
}

//   -- If e is a glvalue conditional expression, ...
// We don't apply this to a binary conditional operator. FIXME: Should we?
case Expr::ConditionalOperatorClass: {
  auto *CO = cast<ConditionalOperator>(E);
  ExprResult LHS = Rebuild(CO->getLHS());
  if (LHS.isInvalid())
    return ExprError();
  ExprResult RHS = Rebuild(CO->getRHS());
  if (RHS.isInvalid())
    return ExprError();
  if (!LHS.isUsable() && !RHS.isUsable())
    return ExprEmpty();
  if (!LHS.isUsable())
    LHS = CO->getLHS();
  if (!RHS.isUsable())
    RHS = CO->getRHS();
  return S.ActOnConditionalOp(CO->getQuestionLoc(), CO->getColonLoc(),
                              CO->getCond(), LHS.get(), RHS.get());
}

// [Clang extension]
//   -- If e has the form __extension__ e1...
case Expr::UnaryOperatorClass: {
  auto *UO = cast<UnaryOperator>(E);
  if (UO->getOpcode() != UO_Extension)
    break;
  ExprResult Sub = Rebuild(UO->getSubExpr());
  if (!Sub.isUsable())
    return Sub;
  return S.BuildUnaryOp(nullptr, UO->getOperatorLoc(), UO_Extension,
                        Sub.get());
}

// [Clang extension]
//   -- If e has the form _Generic(...), the set of potential results is the
//      union of the sets of potential results of the associated expressions.
case Expr::GenericSelectionExprClass: {
  auto *GSE = cast<GenericSelectionExpr>(E);

  SmallVector<Expr *, 4> AssocExprs;
  bool AnyChanged = false;
  for (Expr *OrigAssocExpr : GSE->getAssocExprs()) {
    ExprResult AssocExpr = Rebuild(OrigAssocExpr);
    if (AssocExpr.isInvalid())
      return ExprError();
    if (AssocExpr.isUsable()) {
      AssocExprs.push_back(AssocExpr.get());
      AnyChanged = true;
    } else {
      AssocExprs.push_back(OrigAssocExpr);
    }
  }

  return AnyChanged ? S.CreateGenericSelectionExpr(
                          GSE->getGenericLoc(), GSE->getDefaultLoc(),
                          GSE->getRParenLoc(), GSE->getControllingExpr(),
                          GSE->getAssocTypeSourceInfos(), AssocExprs)
                    : ExprEmpty();
}

// [Clang extension]
//   -- If e has the form __builtin_choose_expr(...), the set of potential
//      results is the union of the sets of potential results of the
//      second and third subexpressions.
case Expr::ChooseExprClass: {
  auto *CE = cast<ChooseExpr>(E);

  ExprResult LHS = Rebuild(CE->getLHS());
  if (LHS.isInvalid())
    return ExprError();

  ExprResult RHS = Rebuild(CE->getLHS());
  if (RHS.isInvalid())
    return ExprError();

  if (!LHS.get() && !RHS.get())
    return ExprEmpty();
  if (!LHS.isUsable())
    LHS = CE->getLHS();
  if (!RHS.isUsable())
    RHS = CE->getRHS();

  return S.ActOnChooseExpr(CE->getBuiltinLoc(), CE->getCond(), LHS.get(),
                           RHS.get(), CE->getRParenLoc());
}

// Step through non-syntactic nodes.
case Expr::ConstantExprClass: {
  auto *CE = cast<ConstantExpr>(E);
  ExprResult Sub = Rebuild(CE->getSubExpr());
  if (!Sub.isUsable())
    return Sub;
  return ConstantExpr::Create(S.Context, Sub.get());
}

// We could mostly rely on the recursive rebuilding to rebuild implicit
// casts, but not at the top level, so rebuild them here.
case Expr::ImplicitCastExprClass: {
  auto *ICE = cast<ImplicitCastExpr>(E);
  // Only step through the narrow set of cast kinds we expect to encounter.
  // Anything else suggests we've left the region in which potential results
  // can be found.
  switch (ICE->getCastKind()) {
  case CK_NoOp:
  case CK_DerivedToBase:
  case CK_UncheckedDerivedToBase: {
    ExprResult Sub = Rebuild(ICE->getSubExpr());
    if (!Sub.isUsable())
      return Sub;
    CXXCastPath Path(ICE->path());
    return S.ImpCastExprToType(Sub.get(), ICE->getType(), ICE->getCastKind(),
                               ICE->getValueKind(), &Path);
  }

  default:
    break;
  }
  break;
}

default:
  break;
}

// Can't traverse through this node. Nothing to do.
return ExprEmpty();
19866}

19868ExprResult Sema::CheckLValueToRValueConversionOperand(Expr *E) {
// Check whether the operand is or contains an object of non-trivial C union
// type.
if (E->getType().isVolatileQualified() &&
    (E->getType().hasNonTrivialToPrimitiveDestructCUnion() ||
     E->getType().hasNonTrivialToPrimitiveCopyCUnion()))
  checkNonTrivialCUnion(E->getType(), E->getExprLoc(),
                        Sema::NTCUC_LValueToRValueVolatile,
                        NTCUK_Destruct|NTCUK_Copy);

// C++2a [basic.def.odr]p4:
//   [...] an expression of non-volatile-qualified non-class type to which
//   the lvalue-to-rvalue conversion is applied [...]
if (E->getType().isVolatileQualified() || E->getType()->getAs<RecordType>())
  return E;

ExprResult Result =
    rebuildPotentialResultsAsNonOdrUsed(*this, E, NOUR_Constant);
if (Result.isInvalid())
  return ExprError();
return Result.get() ? Result : E;
19889}

19891ExprResult Sema::ActOnConstantExpression(ExprResult Res) {
Res = CorrectDelayedTyposInExpr(Res);

if (!Res.isUsable())
  return Res;

// If a constant-expression is a reference to a variable where we delay
// deciding whether it is an odr-use, just assume we will apply the
// lvalue-to-rvalue conversion.  In the one case where this doesn't happen
// (a non-type template argument), we have special handling anyway.
return CheckLValueToRValueConversionOperand(Res.get());
19902}

19904void Sema::CleanupVarDeclMarking() {
// Iterate through a local copy in case MarkVarDeclODRUsed makes a recursive
// call.
MaybeODRUseExprSet LocalMaybeODRUseExprs;
std::swap(LocalMaybeODRUseExprs, MaybeODRUseExprs);

for (Expr *E : LocalMaybeODRUseExprs) {
  if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
    MarkVarDeclODRUsed(cast<VarDecl>(DRE->getDecl()),
                       DRE->getLocation(), *this);
  } else if (auto *ME = dyn_cast<MemberExpr>(E)) {
    MarkVarDeclODRUsed(cast<VarDecl>(ME->getMemberDecl()), ME->getMemberLoc(),
                       *this);
  } else if (auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
    for (VarDecl *VD : *FP)
      MarkVarDeclODRUsed(VD, FP->getParameterPackLocation(), *this);
  } else {
    llvm_unreachable("Unexpected expression")::llvm::llvm_unreachable_internal("Unexpected expression", "clang/lib/Sema/SemaExpr.cpp"
, 19921);
  }
}

assert(MaybeODRUseExprs.empty() &&(static_cast <bool> (MaybeODRUseExprs.empty() &&
 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?") ? void
 (0) : __assert_fail ("MaybeODRUseExprs.empty() && \"MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?\""
, "clang/lib/Sema/SemaExpr.cpp", 19926, __extension__ __PRETTY_FUNCTION__
))
       "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?")(static_cast <bool> (MaybeODRUseExprs.empty() &&
 "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?") ? void
 (0) : __assert_fail ("MaybeODRUseExprs.empty() && \"MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?\""
, "clang/lib/Sema/SemaExpr.cpp", 19926, __extension__ __PRETTY_FUNCTION__
));
19927}

19929static void DoMarkPotentialCapture(Sema &SemaRef, SourceLocation Loc,
                                 ValueDecl *Var, Expr *E) {
VarDecl *VD = Var->getPotentiallyDecomposedVarDecl();
if (!VD)
  return;

const bool RefersToEnclosingScope =
    (SemaRef.CurContext != VD->getDeclContext() &&
     VD->getDeclContext()->isFunctionOrMethod() && VD->hasLocalStorage());
if (RefersToEnclosingScope) {
  LambdaScopeInfo *const LSI =
      SemaRef.getCurLambda(/*IgnoreNonLambdaCapturingScope=*/true);
  if (LSI && (!LSI->CallOperator ||
              !LSI->CallOperator->Encloses(Var->getDeclContext()))) {
    // If a variable could potentially be odr-used, defer marking it so
    // until we finish analyzing the full expression for any
    // lvalue-to-rvalue
    // or discarded value conversions that would obviate odr-use.
    // Add it to the list of potential captures that will be analyzed
    // later (ActOnFinishFullExpr) for eventual capture and odr-use marking
    // unless the variable is a reference that was initialized by a constant
    // expression (this will never need to be captured or odr-used).
    //
    // FIXME: We can simplify this a lot after implementing P0588R1.
    assert(E && "Capture variable should be used in an expression.")(static_cast <bool> (E && "Capture variable should be used in an expression."
) ? void (0) : __assert_fail ("E && \"Capture variable should be used in an expression.\""
, "clang/lib/Sema/SemaExpr.cpp", 19953, __extension__ __PRETTY_FUNCTION__
));
    if (!Var->getType()->isReferenceType() ||
        !VD->isUsableInConstantExpressions(SemaRef.Context))
      LSI->addPotentialCapture(E->IgnoreParens());
  }
}
19959}

19961static void DoMarkVarDeclReferenced(
  Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E,
  llvm::DenseMap<const VarDecl *, int> &RefsMinusAssignments) {
assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||(static_cast <bool> ((!E || isa<DeclRefExpr>(E) ||
 isa<MemberExpr>(E) || isa<FunctionParmPackExpr>(
E)) && "Invalid Expr argument to DoMarkVarDeclReferenced"
) ? void (0) : __assert_fail ("(!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) || isa<FunctionParmPackExpr>(E)) && \"Invalid Expr argument to DoMarkVarDeclReferenced\""
, "clang/lib/Sema/SemaExpr.cpp", 19966, __extension__ __PRETTY_FUNCTION__
))
        isa<FunctionParmPackExpr>(E)) &&(static_cast <bool> ((!E || isa<DeclRefExpr>(E) ||
 isa<MemberExpr>(E) || isa<FunctionParmPackExpr>(
E)) && "Invalid Expr argument to DoMarkVarDeclReferenced"
) ? void (0) : __assert_fail ("(!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) || isa<FunctionParmPackExpr>(E)) && \"Invalid Expr argument to DoMarkVarDeclReferenced\""
, "clang/lib/Sema/SemaExpr.cpp", 19966, __extension__ __PRETTY_FUNCTION__
))
       "Invalid Expr argument to DoMarkVarDeclReferenced")(static_cast <bool> ((!E || isa<DeclRefExpr>(E) ||
 isa<MemberExpr>(E) || isa<FunctionParmPackExpr>(
E)) && "Invalid Expr argument to DoMarkVarDeclReferenced"
) ? void (0) : __assert_fail ("(!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) || isa<FunctionParmPackExpr>(E)) && \"Invalid Expr argument to DoMarkVarDeclReferenced\""
, "clang/lib/Sema/SemaExpr.cpp", 19966, __extension__ __PRETTY_FUNCTION__
));
Var->setReferenced();

if (Var->isInvalidDecl())
  return;

auto *MSI = Var->getMemberSpecializationInfo();
TemplateSpecializationKind TSK = MSI ? MSI->getTemplateSpecializationKind()
                                     : Var->getTemplateSpecializationKind();

OdrUseContext OdrUse = isOdrUseContext(SemaRef);
bool UsableInConstantExpr =
    Var->mightBeUsableInConstantExpressions(SemaRef.Context);

if (Var->isLocalVarDeclOrParm() && !Var->hasExternalStorage()) {
  RefsMinusAssignments.insert({Var, 0}).first->getSecond()++;
}

// C++20 [expr.const]p12:
//   A variable [...] is needed for constant evaluation if it is [...] a
//   variable whose name appears as a potentially constant evaluated
//   expression that is either a contexpr variable or is of non-volatile
//   const-qualified integral type or of reference type
bool NeededForConstantEvaluation =
    isPotentiallyConstantEvaluatedContext(SemaRef) && UsableInConstantExpr;

bool NeedDefinition =
    OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;

assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&(static_cast <bool> (!isa<VarTemplatePartialSpecializationDecl
>(Var) && "Can't instantiate a partial template specialization."
) ? void (0) : __assert_fail ("!isa<VarTemplatePartialSpecializationDecl>(Var) && \"Can't instantiate a partial template specialization.\""
, "clang/lib/Sema/SemaExpr.cpp", 19996, __extension__ __PRETTY_FUNCTION__
))
       "Can't instantiate a partial template specialization.")(static_cast <bool> (!isa<VarTemplatePartialSpecializationDecl
>(Var) && "Can't instantiate a partial template specialization."
) ? void (0) : __assert_fail ("!isa<VarTemplatePartialSpecializationDecl>(Var) && \"Can't instantiate a partial template specialization.\""
, "clang/lib/Sema/SemaExpr.cpp", 19996, __extension__ __PRETTY_FUNCTION__
));

// If this might be a member specialization of a static data member, check
// the specialization is visible. We already did the checks for variable
// template specializations when we created them.
if (NeedDefinition && TSK != TSK_Undeclared &&
    !isa<VarTemplateSpecializationDecl>(Var))
  SemaRef.checkSpecializationVisibility(Loc, Var);

// Perform implicit instantiation of static data members, static data member
// templates of class templates, and variable template specializations. Delay
// instantiations of variable templates, except for those that could be used
// in a constant expression.
if (NeedDefinition && isTemplateInstantiation(TSK)) {
  // Per C++17 [temp.explicit]p10, we may instantiate despite an explicit
  // instantiation declaration if a variable is usable in a constant
  // expression (among other cases).
  bool TryInstantiating =
      TSK == TSK_ImplicitInstantiation ||
      (TSK == TSK_ExplicitInstantiationDeclaration && UsableInConstantExpr);

  if (TryInstantiating) {
    SourceLocation PointOfInstantiation =
        MSI ? MSI->getPointOfInstantiation() : Var->getPointOfInstantiation();
    bool FirstInstantiation = PointOfInstantiation.isInvalid();
    if (FirstInstantiation) {
      PointOfInstantiation = Loc;
      if (MSI)
        MSI->setPointOfInstantiation(PointOfInstantiation);
        // FIXME: Notify listener.
      else
        Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
    }

    if (UsableInConstantExpr) {
      // Do not defer instantiations of variables that could be used in a
      // constant expression.
      SemaRef.runWithSufficientStackSpace(PointOfInstantiation, [&] {
        SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
      });

      // Re-set the member to trigger a recomputation of the dependence bits
      // for the expression.
      if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
        DRE->setDecl(DRE->getDecl());
      else if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
        ME->setMemberDecl(ME->getMemberDecl());
    } else if (FirstInstantiation) {
      SemaRef.PendingInstantiations
          .push_back(std::make_pair(Var, PointOfInstantiation));
    } else {
      bool Inserted = false;
      for (auto &I : SemaRef.SavedPendingInstantiations) {
        auto Iter = llvm::find_if(
            I, [Var](const Sema::PendingImplicitInstantiation &P) {
              return P.first == Var;
            });
        if (Iter != I.end()) {
          SemaRef.PendingInstantiations.push_back(*Iter);
          I.erase(Iter);
          Inserted = true;
          break;
        }
      }

      // FIXME: For a specialization of a variable template, we don't
      // distinguish between "declaration and type implicitly instantiated"
      // and "implicit instantiation of definition requested", so we have
      // no direct way to avoid enqueueing the pending instantiation
      // multiple times.
      if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
        SemaRef.PendingInstantiations
          .push_back(std::make_pair(Var, PointOfInstantiation));
    }
  }
}

// C++2a [basic.def.odr]p4:
//   A variable x whose name appears as a potentially-evaluated expression e
//   is odr-used by e unless
//   -- x is a reference that is usable in constant expressions
//   -- x is a variable of non-reference type that is usable in constant
//      expressions and has no mutable subobjects [FIXME], and e is an
//      element of the set of potential results of an expression of
//      non-volatile-qualified non-class type to which the lvalue-to-rvalue
//      conversion is applied
//   -- x is a variable of non-reference type, and e is an element of the set
//      of potential results of a discarded-value expression to which the
//      lvalue-to-rvalue conversion is not applied [FIXME]
//
// We check the first part of the second bullet here, and
// Sema::CheckLValueToRValueConversionOperand deals with the second part.
// FIXME: To get the third bullet right, we need to delay this even for
// variables that are not usable in constant expressions.

// If we already know this isn't an odr-use, there's nothing more to do.
if (DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
  if (DRE->isNonOdrUse())
    return;
if (MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
  if (ME->isNonOdrUse())
    return;

switch (OdrUse) {
case OdrUseContext::None:
  // In some cases, a variable may not have been marked unevaluated, if it
  // appears in a defaukt initializer.
  assert((!E || isa<FunctionParmPackExpr>(E) ||(static_cast <bool> ((!E || isa<FunctionParmPackExpr
>(E) || SemaRef.isUnevaluatedContext()) && "missing non-odr-use marking for unevaluated decl ref"
) ? void (0) : __assert_fail ("(!E || isa<FunctionParmPackExpr>(E) || SemaRef.isUnevaluatedContext()) && \"missing non-odr-use marking for unevaluated decl ref\""
, "clang/lib/Sema/SemaExpr.cpp", 20105, __extension__ __PRETTY_FUNCTION__
))
          SemaRef.isUnevaluatedContext()) &&(static_cast <bool> ((!E || isa<FunctionParmPackExpr
>(E) || SemaRef.isUnevaluatedContext()) && "missing non-odr-use marking for unevaluated decl ref"
) ? void (0) : __assert_fail ("(!E || isa<FunctionParmPackExpr>(E) || SemaRef.isUnevaluatedContext()) && \"missing non-odr-use marking for unevaluated decl ref\""
, "clang/lib/Sema/SemaExpr.cpp", 20105, __extension__ __PRETTY_FUNCTION__
))
         "missing non-odr-use marking for unevaluated decl ref")(static_cast <bool> ((!E || isa<FunctionParmPackExpr
>(E) || SemaRef.isUnevaluatedContext()) && "missing non-odr-use marking for unevaluated decl ref"
) ? void (0) : __assert_fail ("(!E || isa<FunctionParmPackExpr>(E) || SemaRef.isUnevaluatedContext()) && \"missing non-odr-use marking for unevaluated decl ref\""
, "clang/lib/Sema/SemaExpr.cpp", 20105, __extension__ __PRETTY_FUNCTION__
));
  break;

case OdrUseContext::FormallyOdrUsed:
  // FIXME: Ignoring formal odr-uses results in incorrect lambda capture
  // behavior.
  break;

case OdrUseContext::Used:
  // If we might later find that this expression isn't actually an odr-use,
  // delay the marking.
  if (E && Var->isUsableInConstantExpressions(SemaRef.Context))
    SemaRef.MaybeODRUseExprs.insert(E);
  else
    MarkVarDeclODRUsed(Var, Loc, SemaRef);
  break;

case OdrUseContext::Dependent:
  // If this is a dependent context, we don't need to mark variables as
  // odr-used, but we may still need to track them for lambda capture.
  // FIXME: Do we also need to do this inside dependent typeid expressions
  // (which are modeled as unevaluated at this point)?
  DoMarkPotentialCapture(SemaRef, Loc, Var, E);
  break;
}
20130}

20132static void DoMarkBindingDeclReferenced(Sema &SemaRef, SourceLocation Loc,
                                      BindingDecl *BD, Expr *E) {
BD->setReferenced();

if (BD->isInvalidDecl())
  return;

OdrUseContext OdrUse = isOdrUseContext(SemaRef);
if (OdrUse == OdrUseContext::Used) {
  QualType CaptureType, DeclRefType;
  SemaRef.tryCaptureVariable(BD, Loc, Sema::TryCapture_Implicit,
                             /*EllipsisLoc*/ SourceLocation(),
                             /*BuildAndDiagnose*/ true, CaptureType,
                             DeclRefType,
                             /*FunctionScopeIndexToStopAt*/ nullptr);
} else if (OdrUse == OdrUseContext::Dependent) {
  DoMarkPotentialCapture(SemaRef, Loc, BD, E);
}
20150}

20152/// Mark a variable referenced, and check whether it is odr-used
20153/// (C++ [basic.def.odr]p2, C99 6.9p3).  Note that this should not be
20154/// used directly for normal expressions referring to VarDecl.
20155void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) {
DoMarkVarDeclReferenced(*this, Loc, Var, nullptr, RefsMinusAssignments);
20157}

20159static void
20160MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E,
                 bool MightBeOdrUse,
                 llvm::DenseMap<const VarDecl *, int> &RefsMinusAssignments) {
if (SemaRef.isInOpenMPDeclareTargetContext())
  SemaRef.checkDeclIsAllowedInOpenMPTarget(E, D);

if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
  DoMarkVarDeclReferenced(SemaRef, Loc, Var, E, RefsMinusAssignments);
  return;
}

if (BindingDecl *Decl = dyn_cast<BindingDecl>(D)) {
  DoMarkBindingDeclReferenced(SemaRef, Loc, Decl, E);
  return;
}

SemaRef.MarkAnyDeclReferenced(Loc, D, MightBeOdrUse);

// If this is a call to a method via a cast, also mark the method in the
// derived class used in case codegen can devirtualize the call.
const MemberExpr *ME = dyn_cast<MemberExpr>(E);
if (!ME)
  return;
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
if (!MD)
  return;
// Only attempt to devirtualize if this is truly a virtual call.
bool IsVirtualCall = MD->isVirtual() &&
                        ME->performsVirtualDispatch(SemaRef.getLangOpts());
if (!IsVirtualCall)
  return;

// If it's possible to devirtualize the call, mark the called function
// referenced.
CXXMethodDecl *DM = MD->getDevirtualizedMethod(
    ME->getBase(), SemaRef.getLangOpts().AppleKext);
if (DM)
  SemaRef.MarkAnyDeclReferenced(Loc, DM, MightBeOdrUse);
20198}

20200/// Perform reference-marking and odr-use handling for a DeclRefExpr.
20201///
20202/// Note, this may change the dependence of the DeclRefExpr, and so needs to be
20203/// handled with care if the DeclRefExpr is not newly-created.
20204void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) {
// TODO: update this with DR# once a defect report is filed.
// C++11 defect. The address of a pure member should not be an ODR use, even
// if it's a qualified reference.
bool OdrUse = true;
if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
  if (Method->isVirtual() &&
      !Method->getDevirtualizedMethod(Base, getLangOpts().AppleKext))
    OdrUse = false;

if (auto *FD = dyn_cast<FunctionDecl>(E->getDecl()))
  if (!isUnevaluatedContext() && !isConstantEvaluated() &&
      !isImmediateFunctionContext() &&
      !isCheckingDefaultArgumentOrInitializer() && FD->isConsteval() &&
      !RebuildingImmediateInvocation && !FD->isDependentContext())
    ExprEvalContexts.back().ReferenceToConsteval.insert(E);
MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse,
                   RefsMinusAssignments);
20222}

20224/// Perform reference-marking and odr-use handling for a MemberExpr.
20225void Sema::MarkMemberReferenced(MemberExpr *E) {
// C++11 [basic.def.odr]p2:
//   A non-overloaded function whose name appears as a potentially-evaluated
//   expression or a member of a set of candidate functions, if selected by
//   overload resolution when referred to from a potentially-evaluated
//   expression, is odr-used, unless it is a pure virtual function and its
//   name is not explicitly qualified.
bool MightBeOdrUse = true;
if (E->performsVirtualDispatch(getLangOpts())) {
  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getMemberDecl()))
    if (Method->isPure())
      MightBeOdrUse = false;
}
SourceLocation Loc =
    E->getMemberLoc().isValid() ? E->getMemberLoc() : E->getBeginLoc();
MarkExprReferenced(*this, Loc, E->getMemberDecl(), E, MightBeOdrUse,
                   RefsMinusAssignments);
20242}

20244/// Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
20245void Sema::MarkFunctionParmPackReferenced(FunctionParmPackExpr *E) {
for (VarDecl *VD : *E)
  MarkExprReferenced(*this, E->getParameterPackLocation(), VD, E, true,
                     RefsMinusAssignments);
20249}

20251/// Perform marking for a reference to an arbitrary declaration.  It
20252/// marks the declaration referenced, and performs odr-use checking for
20253/// functions and variables. This method should not be used when building a
20254/// normal expression which refers to a variable.
20255void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D,
                               bool MightBeOdrUse) {
if (MightBeOdrUse) {
  if (auto *VD = dyn_cast<VarDecl>(D)) {
    MarkVariableReferenced(Loc, VD);
    return;
  }
}
if (auto *FD = dyn_cast<FunctionDecl>(D)) {
  MarkFunctionReferenced(Loc, FD, MightBeOdrUse);
  return;
}
D->setReferenced();
20268}

20270namespace {
// Mark all of the declarations used by a type as referenced.
// FIXME: Not fully implemented yet! We need to have a better understanding
// of when we're entering a context we should not recurse into.
// FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
// TreeTransforms rebuilding the type in a new context. Rather than
// duplicating the TreeTransform logic, we should consider reusing it here.
// Currently that causes problems when rebuilding LambdaExprs.
class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> {
  Sema &S;
  SourceLocation Loc;

public:
  typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited;

  MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { }

  bool TraverseTemplateArgument(const TemplateArgument &Arg);
};
20289}

20291bool MarkReferencedDecls::TraverseTemplateArgument(
  const TemplateArgument &Arg) {
{
  // A non-type template argument is a constant-evaluated context.
  EnterExpressionEvaluationContext Evaluated(
      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  if (Arg.getKind() == TemplateArgument::Declaration) {
    if (Decl *D = Arg.getAsDecl())
      S.MarkAnyDeclReferenced(Loc, D, true);
  } else if (Arg.getKind() == TemplateArgument::Expression) {
    S.MarkDeclarationsReferencedInExpr(Arg.getAsExpr(), false);
  }
}

return Inherited::TraverseTemplateArgument(Arg);
20306}

20308void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) {
MarkReferencedDecls Marker(*this, Loc);
Marker.TraverseType(T);
20311}

20313namespace {
20314/// Helper class that marks all of the declarations referenced by
20315/// potentially-evaluated subexpressions as "referenced".
20316class EvaluatedExprMarker : public UsedDeclVisitor<EvaluatedExprMarker> {
20317public:
typedef UsedDeclVisitor<EvaluatedExprMarker> Inherited;
bool SkipLocalVariables;
ArrayRef<const Expr *> StopAt;

EvaluatedExprMarker(Sema &S, bool SkipLocalVariables,
                    ArrayRef<const Expr *> StopAt)
    : Inherited(S), SkipLocalVariables(SkipLocalVariables), StopAt(StopAt) {}

void visitUsedDecl(SourceLocation Loc, Decl *D) {
  S.MarkFunctionReferenced(Loc, cast<FunctionDecl>(D));
}

void Visit(Expr *E) {
  if (llvm::is_contained(StopAt, E))
    return;
  Inherited::Visit(E);
}

void VisitConstantExpr(ConstantExpr *E) {
  // Don't mark declarations within a ConstantExpression, as this expression
  // will be evaluated and folded to a value.
}

void VisitDeclRefExpr(DeclRefExpr *E) {
  // If we were asked not to visit local variables, don't.
  if (SkipLocalVariables) {
    if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
      if (VD->hasLocalStorage())
        return;
  }

  // FIXME: This can trigger the instantiation of the initializer of a
  // variable, which can cause the expression to become value-dependent
  // or error-dependent. Do we need to propagate the new dependence bits?
  S.MarkDeclRefReferenced(E);
}

void VisitMemberExpr(MemberExpr *E) {
  S.MarkMemberReferenced(E);
  Visit(E->getBase());
}
20359};
20360} // namespace

20362/// Mark any declarations that appear within this expression or any
20363/// potentially-evaluated subexpressions as "referenced".
20364///
20365/// \param SkipLocalVariables If true, don't mark local variables as
20366/// 'referenced'.
20367/// \param StopAt Subexpressions that we shouldn't recurse into.
20368void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
                                          bool SkipLocalVariables,
                                          ArrayRef<const Expr*> StopAt) {
EvaluatedExprMarker(*this, SkipLocalVariables, StopAt).Visit(E);
20372}

20374/// Emit a diagnostic when statements are reachable.
20375/// FIXME: check for reachability even in expressions for which we don't build a
20376///        CFG (eg, in the initializer of a global or in a constant expression).
20377///        For example,
20378///        namespace { auto *p = new double[3][false ? (1, 2) : 3]; }
20379bool Sema::DiagIfReachable(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
                         const PartialDiagnostic &PD) {
if (!Stmts.empty() && getCurFunctionOrMethodDecl()) {
  if (!FunctionScopes.empty())
    FunctionScopes.back()->PossiblyUnreachableDiags.push_back(
        sema::PossiblyUnreachableDiag(PD, Loc, Stmts));
  return true;
}

// The initializer of a constexpr variable or of the first declaration of a
// static data member is not syntactically a constant evaluated constant,
// but nonetheless is always required to be a constant expression, so we
// can skip diagnosing.
// FIXME: Using the mangling context here is a hack.
if (auto *VD = dyn_cast_or_null<VarDecl>(
        ExprEvalContexts.back().ManglingContextDecl)) {
  if (VD->isConstexpr() ||
      (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
    return false;
  // FIXME: For any other kind of variable, we should build a CFG for its
  // initializer and check whether the context in question is reachable.
}

Diag(Loc, PD);
return true;
20404}

20406/// Emit a diagnostic that describes an effect on the run-time behavior
20407/// of the program being compiled.
20408///
20409/// This routine emits the given diagnostic when the code currently being
20410/// type-checked is "potentially evaluated", meaning that there is a
20411/// possibility that the code will actually be executable. Code in sizeof()
20412/// expressions, code used only during overload resolution, etc., are not
20413/// potentially evaluated. This routine will suppress such diagnostics or,
20414/// in the absolutely nutty case of potentially potentially evaluated
20415/// expressions (C++ typeid), queue the diagnostic to potentially emit it
20416/// later.
20417///
20418/// This routine should be used for all diagnostics that describe the run-time
20419/// behavior of a program, such as passing a non-POD value through an ellipsis.
20420/// Failure to do so will likely result in spurious diagnostics or failures
20421/// during overload resolution or within sizeof/alignof/typeof/typeid.
20422bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
                             const PartialDiagnostic &PD) {

if (ExprEvalContexts.back().isDiscardedStatementContext())
  return false;

switch (ExprEvalContexts.back().Context) {
case ExpressionEvaluationContext::Unevaluated:
case ExpressionEvaluationContext::UnevaluatedList:
case ExpressionEvaluationContext::UnevaluatedAbstract:
case ExpressionEvaluationContext::DiscardedStatement:
  // The argument will never be evaluated, so don't complain.
  break;

case ExpressionEvaluationContext::ConstantEvaluated:
case ExpressionEvaluationContext::ImmediateFunctionContext:
  // Relevant diagnostics should be produced by constant evaluation.
  break;

case ExpressionEvaluationContext::PotentiallyEvaluated:
case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
  return DiagIfReachable(Loc, Stmts, PD);
}

return false;
20447}

20449bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
                             const PartialDiagnostic &PD) {
return DiagRuntimeBehavior(
    Loc, Statement ? llvm::ArrayRef(Statement) : std::nullopt, PD);
20453}

20455bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
                             CallExpr *CE, FunctionDecl *FD) {
if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
  return false;

// If we're inside a decltype's expression, don't check for a valid return
// type or construct temporaries until we know whether this is the last call.
if (ExprEvalContexts.back().ExprContext ==
    ExpressionEvaluationContextRecord::EK_Decltype) {
  ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE);
  return false;
}

class CallReturnIncompleteDiagnoser : public TypeDiagnoser {
  FunctionDecl *FD;
  CallExpr *CE;

public:
  CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
    : FD(FD), CE(CE) { }

  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
    if (!FD) {
      S.Diag(Loc, diag::err_call_incomplete_return)
        << T << CE->getSourceRange();
      return;
    }

    S.Diag(Loc, diag::err_call_function_incomplete_return)
        << CE->getSourceRange() << FD << T;
    S.Diag(FD->getLocation(), diag::note_entity_declared_at)
        << FD->getDeclName();
  }
} Diagnoser(FD, CE);

if (RequireCompleteType(Loc, ReturnType, Diagnoser))
  return true;

return false;
20494}

20496// Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses
20497// will prevent this condition from triggering, which is what we want.
20498void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
SourceLocation Loc;

unsigned diagnostic = diag::warn_condition_is_assignment;
bool IsOrAssign = false;

if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
  if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
    return;

  IsOrAssign = Op->getOpcode() == BO_OrAssign;

  // Greylist some idioms by putting them into a warning subcategory.
  if (ObjCMessageExpr *ME
        = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
    Selector Sel = ME->getSelector();

    // self = [<foo> init...]
    if (isSelfExpr(Op->getLHS()) && ME->getMethodFamily() == OMF_init)
      diagnostic = diag::warn_condition_is_idiomatic_assignment;

    // <foo> = [<bar> nextObject]
    else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject")
      diagnostic = diag::warn_condition_is_idiomatic_assignment;
  }

  Loc = Op->getOperatorLoc();
} else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
  if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
    return;

  IsOrAssign = Op->getOperator() == OO_PipeEqual;
  Loc = Op->getOperatorLoc();
} else if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
  return DiagnoseAssignmentAsCondition(POE->getSyntacticForm());
else {
  // Not an assignment.
  return;
}

Diag(Loc, diagnostic) << E->getSourceRange();

SourceLocation Open = E->getBeginLoc();
SourceLocation Close = getLocForEndOfToken(E->getSourceRange().getEnd());
Diag(Loc, diag::note_condition_assign_silence)
      << FixItHint::CreateInsertion(Open, "(")
      << FixItHint::CreateInsertion(Close, ")");

if (IsOrAssign)
  Diag(Loc, diag::note_condition_or_assign_to_comparison)
    << FixItHint::CreateReplacement(Loc, "!=");
else
  Diag(Loc, diag::note_condition_assign_to_comparison)
    << FixItHint::CreateReplacement(Loc, "==");
20552}

20554/// Redundant parentheses over an equality comparison can indicate
20555/// that the user intended an assignment used as condition.
20556void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) {
// Don't warn if the parens came from a macro.
SourceLocation parenLoc = ParenE->getBeginLoc();
if (parenLoc.isInvalid() || parenLoc.isMacroID())
  return;
// Don't warn for dependent expressions.
if (ParenE->isTypeDependent())
  return;

Expr *E = ParenE->IgnoreParens();

if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E))
  if (opE->getOpcode() == BO_EQ &&
      opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context)
                                                         == Expr::MLV_Valid) {
    SourceLocation Loc = opE->getOperatorLoc();

    Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange();
    SourceRange ParenERange = ParenE->getSourceRange();
    Diag(Loc, diag::note_equality_comparison_silence)
      << FixItHint::CreateRemoval(ParenERange.getBegin())
      << FixItHint::CreateRemoval(ParenERange.getEnd());
    Diag(Loc, diag::note_equality_comparison_to_assign)
      << FixItHint::CreateReplacement(Loc, "=");
  }
20581}

20583ExprResult Sema::CheckBooleanCondition(SourceLocation Loc, Expr *E,
                                     bool IsConstexpr) {
DiagnoseAssignmentAsCondition(E);
if (ParenExpr *parenE = dyn_cast<ParenExpr>(E))
  DiagnoseEqualityWithExtraParens(parenE);

ExprResult result = CheckPlaceholderExpr(E);
if (result.isInvalid()) return ExprError();
E = result.get();

if (!E->isTypeDependent()) {
  if (getLangOpts().CPlusPlus)
    return CheckCXXBooleanCondition(E, IsConstexpr); // C++ 6.4p4

  ExprResult ERes = DefaultFunctionArrayLvalueConversion(E);
  if (ERes.isInvalid())
    return ExprError();
  E = ERes.get();

  QualType T = E->getType();
  if (!T->isScalarType()) { // C99 6.8.4.1p1
    Diag(Loc, diag::err_typecheck_statement_requires_scalar)
      << T << E->getSourceRange();
    return ExprError();
  }
  CheckBoolLikeConversion(E, Loc);
}

return E;
20612}

20614Sema::ConditionResult Sema::ActOnCondition(Scope *S, SourceLocation Loc,
                                         Expr *SubExpr, ConditionKind CK,
                                         bool MissingOK) {
// MissingOK indicates whether having no condition expression is valid
// (for loop) or invalid (e.g. while loop).
if (!SubExpr)
  return MissingOK ? ConditionResult() : ConditionError();

ExprResult Cond;
switch (CK) {
case ConditionKind::Boolean:
  Cond = CheckBooleanCondition(Loc, SubExpr);
  break;

case ConditionKind::ConstexprIf:
  Cond = CheckBooleanCondition(Loc, SubExpr, true);
  break;

case ConditionKind::Switch:
  Cond = CheckSwitchCondition(Loc, SubExpr);
  break;
}
if (Cond.isInvalid()) {
  Cond = CreateRecoveryExpr(SubExpr->getBeginLoc(), SubExpr->getEndLoc(),
                            {SubExpr}, PreferredConditionType(CK));
  if (!Cond.get())
    return ConditionError();
}
// FIXME: FullExprArg doesn't have an invalid bit, so check nullness instead.
FullExprArg FullExpr = MakeFullExpr(Cond.get(), Loc);
if (!FullExpr.get())
  return ConditionError();

return ConditionResult(*this, nullptr, FullExpr,
                       CK == ConditionKind::ConstexprIf);
20649}

20651namespace {
/// A visitor for rebuilding a call to an __unknown_any expression
/// to have an appropriate type.
struct RebuildUnknownAnyFunction
  : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {

  Sema &S;

  RebuildUnknownAnyFunction(Sema &S) : S(S) {}

  ExprResult VisitStmt(Stmt *S) {
    llvm_unreachable("unexpected statement!")::llvm::llvm_unreachable_internal("unexpected statement!", "clang/lib/Sema/SemaExpr.cpp"
, 20662);
  }

  ExprResult VisitExpr(Expr *E) {
    S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
      << E->getSourceRange();
    return ExprError();
  }

  /// Rebuild an expression which simply semantically wraps another
  /// expression which it shares the type and value kind of.
  template <class T> ExprResult rebuildSugarExpr(T *E) {
    ExprResult SubResult = Visit(E->getSubExpr());
    if (SubResult.isInvalid()) return ExprError();

    Expr *SubExpr = SubResult.get();
    E->setSubExpr(SubExpr);
    E->setType(SubExpr->getType());
    E->setValueKind(SubExpr->getValueKind());
    assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20681, __extension__ __PRETTY_FUNCTION__
));
    return E;
  }

  ExprResult VisitParenExpr(ParenExpr *E) {
    return rebuildSugarExpr(E);
  }

  ExprResult VisitUnaryExtension(UnaryOperator *E) {
    return rebuildSugarExpr(E);
  }

  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
    ExprResult SubResult = Visit(E->getSubExpr());
    if (SubResult.isInvalid()) return ExprError();

    Expr *SubExpr = SubResult.get();
    E->setSubExpr(SubExpr);
    E->setType(S.Context.getPointerType(SubExpr->getType()));
    assert(E->isPRValue())(static_cast <bool> (E->isPRValue()) ? void (0) : __assert_fail
 ("E->isPRValue()", "clang/lib/Sema/SemaExpr.cpp", 20700, __extension__
 __PRETTY_FUNCTION__));
    assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20701, __extension__ __PRETTY_FUNCTION__
));
    return E;
  }

  ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
    if (!isa<FunctionDecl>(VD)) return VisitExpr(E);

    E->setType(VD->getType());

    assert(E->isPRValue())(static_cast <bool> (E->isPRValue()) ? void (0) : __assert_fail
 ("E->isPRValue()", "clang/lib/Sema/SemaExpr.cpp", 20710, __extension__
 __PRETTY_FUNCTION__));
    if (S.getLangOpts().CPlusPlus &&
        !(isa<CXXMethodDecl>(VD) &&
          cast<CXXMethodDecl>(VD)->isInstance()))
      E->setValueKind(VK_LValue);

    return E;
  }

  ExprResult VisitMemberExpr(MemberExpr *E) {
    return resolveDecl(E, E->getMemberDecl());
  }

  ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
    return resolveDecl(E, E->getDecl());
  }
};
20727}

20729/// Given a function expression of unknown-any type, try to rebuild it
20730/// to have a function type.
20731static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
if (Result.isInvalid()) return ExprError();
return S.DefaultFunctionArrayConversion(Result.get());
20735}

20737namespace {
/// A visitor for rebuilding an expression of type __unknown_anytype
/// into one which resolves the type directly on the referring
/// expression.  Strict preservation of the original source
/// structure is not a goal.
struct RebuildUnknownAnyExpr
  : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {

  Sema &S;

  /// The current destination type.
  QualType DestType;

  RebuildUnknownAnyExpr(Sema &S, QualType CastType)
    : S(S), DestType(CastType) {}

  ExprResult VisitStmt(Stmt *S) {
    llvm_unreachable("unexpected statement!")::llvm::llvm_unreachable_internal("unexpected statement!", "clang/lib/Sema/SemaExpr.cpp"
, 20754);
  }

  ExprResult VisitExpr(Expr *E) {
    S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
      << E->getSourceRange();
    return ExprError();
  }

  ExprResult VisitCallExpr(CallExpr *E);
  ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);

  /// Rebuild an expression which simply semantically wraps another
  /// expression which it shares the type and value kind of.
  template <class T> ExprResult rebuildSugarExpr(T *E) {
    ExprResult SubResult = Visit(E->getSubExpr());
    if (SubResult.isInvalid()) return ExprError();
    Expr *SubExpr = SubResult.get();
    E->setSubExpr(SubExpr);
    E->setType(SubExpr->getType());
    E->setValueKind(SubExpr->getValueKind());
    assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20775, __extension__ __PRETTY_FUNCTION__
));
    return E;
  }

  ExprResult VisitParenExpr(ParenExpr *E) {
    return rebuildSugarExpr(E);
  }

  ExprResult VisitUnaryExtension(UnaryOperator *E) {
    return rebuildSugarExpr(E);
  }

  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
    const PointerType *Ptr = DestType->getAs<PointerType>();
    if (!Ptr) {
      S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
        << E->getSourceRange();
      return ExprError();
    }

    if (isa<CallExpr>(E->getSubExpr())) {
      S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
        << E->getSourceRange();
      return ExprError();
    }

    assert(E->isPRValue())(static_cast <bool> (E->isPRValue()) ? void (0) : __assert_fail
 ("E->isPRValue()", "clang/lib/Sema/SemaExpr.cpp", 20801, __extension__
 __PRETTY_FUNCTION__));
    assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20802, __extension__ __PRETTY_FUNCTION__
));
    E->setType(DestType);

    // Build the sub-expression as if it were an object of the pointee type.
    DestType = Ptr->getPointeeType();
    ExprResult SubResult = Visit(E->getSubExpr());
    if (SubResult.isInvalid()) return ExprError();
    E->setSubExpr(SubResult.get());
    return E;
  }

  ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);

  ExprResult resolveDecl(Expr *E, ValueDecl *VD);

  ExprResult VisitMemberExpr(MemberExpr *E) {
    return resolveDecl(E, E->getMemberDecl());
  }

  ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
    return resolveDecl(E, E->getDecl());
  }
};
20825}

20827/// Rebuilds a call expression which yielded __unknown_anytype.
20828ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
Expr *CalleeExpr = E->getCallee();

enum FnKind {
  FK_MemberFunction,
  FK_FunctionPointer,
  FK_BlockPointer
};

FnKind Kind;
QualType CalleeType = CalleeExpr->getType();
if (CalleeType == S.Context.BoundMemberTy) {
  assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E))(static_cast <bool> (isa<CXXMemberCallExpr>(E) ||
 isa<CXXOperatorCallExpr>(E)) ? void (0) : __assert_fail
 ("isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E)"
, "clang/lib/Sema/SemaExpr.cpp", 20840, __extension__ __PRETTY_FUNCTION__
));
  Kind = FK_MemberFunction;
  CalleeType = Expr::findBoundMemberType(CalleeExpr);
} else if (const PointerType *Ptr = CalleeType->getAs<PointerType>()) {
  CalleeType = Ptr->getPointeeType();
  Kind = FK_FunctionPointer;
} else {
  CalleeType = CalleeType->castAs<BlockPointerType>()->getPointeeType();
  Kind = FK_BlockPointer;
}
const FunctionType *FnType = CalleeType->castAs<FunctionType>();

// Verify that this is a legal result type of a function.
if (DestType->isArrayType() || DestType->isFunctionType()) {
  unsigned diagID = diag::err_func_returning_array_function;
  if (Kind == FK_BlockPointer)
    diagID = diag::err_block_returning_array_function;

  S.Diag(E->getExprLoc(), diagID)
    << DestType->isFunctionType() << DestType;
  return ExprError();
}

// Otherwise, go ahead and set DestType as the call's result.
E->setType(DestType.getNonLValueExprType(S.Context));
E->setValueKind(Expr::getValueKindForType(DestType));
assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20866, __extension__ __PRETTY_FUNCTION__
));

// Rebuild the function type, replacing the result type with DestType.
const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType);
if (Proto) {
  // __unknown_anytype(...) is a special case used by the debugger when
  // it has no idea what a function's signature is.
  //
  // We want to build this call essentially under the K&R
  // unprototyped rules, but making a FunctionNoProtoType in C++
  // would foul up all sorts of assumptions.  However, we cannot
  // simply pass all arguments as variadic arguments, nor can we
  // portably just call the function under a non-variadic type; see
  // the comment on IR-gen's TargetInfo::isNoProtoCallVariadic.
  // However, it turns out that in practice it is generally safe to
  // call a function declared as "A foo(B,C,D);" under the prototype
  // "A foo(B,C,D,...);".  The only known exception is with the
  // Windows ABI, where any variadic function is implicitly cdecl
  // regardless of its normal CC.  Therefore we change the parameter
  // types to match the types of the arguments.
  //
  // This is a hack, but it is far superior to moving the
  // corresponding target-specific code from IR-gen to Sema/AST.

  ArrayRef<QualType> ParamTypes = Proto->getParamTypes();
  SmallVector<QualType, 8> ArgTypes;
  if (ParamTypes.empty() && Proto->isVariadic()) { // the special case
    ArgTypes.reserve(E->getNumArgs());
    for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
      ArgTypes.push_back(S.Context.getReferenceQualifiedType(E->getArg(i)));
    }
    ParamTypes = ArgTypes;
  }
  DestType = S.Context.getFunctionType(DestType, ParamTypes,
                                       Proto->getExtProtoInfo());
} else {
  DestType = S.Context.getFunctionNoProtoType(DestType,
                                              FnType->getExtInfo());
}

// Rebuild the appropriate pointer-to-function type.
switch (Kind) {
case FK_MemberFunction:
  // Nothing to do.
  break;

case FK_FunctionPointer:
  DestType = S.Context.getPointerType(DestType);
  break;

case FK_BlockPointer:
  DestType = S.Context.getBlockPointerType(DestType);
  break;
}

// Finally, we can recurse.
ExprResult CalleeResult = Visit(CalleeExpr);
if (!CalleeResult.isUsable()) return ExprError();
E->setCallee(CalleeResult.get());

// Bind a temporary if necessary.
return S.MaybeBindToTemporary(E);
20928}

20930ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {
// Verify that this is a legal result type of a call.
if (DestType->isArrayType() || DestType->isFunctionType()) {
  S.Diag(E->getExprLoc(), diag::err_func_returning_array_function)
    << DestType->isFunctionType() << DestType;
  return ExprError();
}

// Rewrite the method result type if available.
if (ObjCMethodDecl *Method = E->getMethodDecl()) {
  assert(Method->getReturnType() == S.Context.UnknownAnyTy)(static_cast <bool> (Method->getReturnType() == S.Context
.UnknownAnyTy) ? void (0) : __assert_fail ("Method->getReturnType() == S.Context.UnknownAnyTy"
, "clang/lib/Sema/SemaExpr.cpp", 20940, __extension__ __PRETTY_FUNCTION__
));
  Method->setReturnType(DestType);
}

// Change the type of the message.
E->setType(DestType.getNonReferenceType());
E->setValueKind(Expr::getValueKindForType(DestType));

return S.MaybeBindToTemporary(E);
20949}

20951ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
// The only case we should ever see here is a function-to-pointer decay.
if (E->getCastKind() == CK_FunctionToPointerDecay) {
  assert(E->isPRValue())(static_cast <bool> (E->isPRValue()) ? void (0) : __assert_fail
 ("E->isPRValue()", "clang/lib/Sema/SemaExpr.cpp", 20954, __extension__
 __PRETTY_FUNCTION__));
  assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20955, __extension__ __PRETTY_FUNCTION__
));

  E->setType(DestType);

  // Rebuild the sub-expression as the pointee (function) type.
  DestType = DestType->castAs<PointerType>()->getPointeeType();

  ExprResult Result = Visit(E->getSubExpr());
  if (!Result.isUsable()) return ExprError();

  E->setSubExpr(Result.get());
  return E;
} else if (E->getCastKind() == CK_LValueToRValue) {
  assert(E->isPRValue())(static_cast <bool> (E->isPRValue()) ? void (0) : __assert_fail
 ("E->isPRValue()", "clang/lib/Sema/SemaExpr.cpp", 20968, __extension__
 __PRETTY_FUNCTION__));
  assert(E->getObjectKind() == OK_Ordinary)(static_cast <bool> (E->getObjectKind() == OK_Ordinary
) ? void (0) : __assert_fail ("E->getObjectKind() == OK_Ordinary"
, "clang/lib/Sema/SemaExpr.cpp", 20969, __extension__ __PRETTY_FUNCTION__
));

  assert(isa<BlockPointerType>(E->getType()))(static_cast <bool> (isa<BlockPointerType>(E->
getType())) ? void (0) : __assert_fail ("isa<BlockPointerType>(E->getType())"
, "clang/lib/Sema/SemaExpr.cpp", 20971, __extension__ __PRETTY_FUNCTION__
));

  E->setType(DestType);

  // The sub-expression has to be a lvalue reference, so rebuild it as such.
  DestType = S.Context.getLValueReferenceType(DestType);

  ExprResult Result = Visit(E->getSubExpr());
  if (!Result.isUsable()) return ExprError();

  E->setSubExpr(Result.get());
  return E;
} else {
  llvm_unreachable("Unhandled cast type!")::llvm::llvm_unreachable_internal("Unhandled cast type!", "clang/lib/Sema/SemaExpr.cpp"
, 20984);
}
20986}

20988ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
ExprValueKind ValueKind = VK_LValue;
QualType Type = DestType;

// We know how to make this work for certain kinds of decls:

//  - functions
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {
  if (const PointerType *Ptr = Type->getAs<PointerType>()) {
    DestType = Ptr->getPointeeType();
    ExprResult Result = resolveDecl(E, VD);
    if (Result.isInvalid()) return ExprError();
    return S.ImpCastExprToType(Result.get(), Type, CK_FunctionToPointerDecay,
                               VK_PRValue);
  }

  if (!Type->isFunctionType()) {
    S.Diag(E->getExprLoc(), diag::err_unknown_any_function)
      << VD << E->getSourceRange();
    return ExprError();
  }
  if (const FunctionProtoType *FT = Type->getAs<FunctionProtoType>()) {
    // We must match the FunctionDecl's type to the hack introduced in
    // RebuildUnknownAnyExpr::VisitCallExpr to vararg functions of unknown
    // type. See the lengthy commentary in that routine.
    QualType FDT = FD->getType();
    const FunctionType *FnType = FDT->castAs<FunctionType>();
    const FunctionProtoType *Proto = dyn_cast_or_null<FunctionProtoType>(FnType);
    DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
    if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
      SourceLocation Loc = FD->getLocation();
      FunctionDecl *NewFD = FunctionDecl::Create(
          S.Context, FD->getDeclContext(), Loc, Loc,
          FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
          SC_None, S.getCurFPFeatures().isFPConstrained(),
          false /*isInlineSpecified*/, FD->hasPrototype(),
          /*ConstexprKind*/ ConstexprSpecKind::Unspecified);

      if (FD->getQualifier())
        NewFD->setQualifierInfo(FD->getQualifierLoc());

      SmallVector<ParmVarDecl*, 16> Params;
      for (const auto &AI : FT->param_types()) {
        ParmVarDecl *Param =
          S.BuildParmVarDeclForTypedef(FD, Loc, AI);
        Param->setScopeInfo(0, Params.size());
        Params.push_back(Param);
      }
      NewFD->setParams(Params);
      DRE->setDecl(NewFD);
      VD = DRE->getDecl();
    }
  }

  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
    if (MD->isInstance()) {
      ValueKind = VK_PRValue;
      Type = S.Context.BoundMemberTy;
    }

  // Function references aren't l-values in C.
  if (!S.getLangOpts().CPlusPlus)
    ValueKind = VK_PRValue;

//  - variables
} else if (isa<VarDecl>(VD)) {
  if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {
    Type = RefTy->getPointeeType();
  } else if (Type->isFunctionType()) {
    S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type)
      << VD << E->getSourceRange();
    return ExprError();
  }

//  - nothing else
} else {
  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl)
    << VD << E->getSourceRange();
  return ExprError();
}

// Modifying the declaration like this is friendly to IR-gen but
// also really dangerous.
VD->setType(DestType);
E->setType(Type);
E->setValueKind(ValueKind);
return E;
21075}

21077/// Check a cast of an unknown-any type.  We intentionally only
21078/// trigger this for C-style casts.
21079ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
                                   Expr *CastExpr, CastKind &CastKind,
                                   ExprValueKind &VK, CXXCastPath &Path) {
// The type we're casting to must be either void or complete.
if (!CastType->isVoidType() &&
    RequireCompleteType(TypeRange.getBegin(), CastType,
                        diag::err_typecheck_cast_to_incomplete))
  return ExprError();

// Rewrite the casted expression from scratch.
ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
if (!result.isUsable()) return ExprError();

CastExpr = result.get();
VK = CastExpr->getValueKind();
CastKind = CK_NoOp;

return CastExpr;
21097}

21099ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) {
return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
21101}

21103ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc,
                                  Expr *arg, QualType &paramType) {
// If the syntactic form of the argument is not an explicit cast of
// any sort, just do default argument promotion.
ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
if (!castArg) {
  ExprResult result = DefaultArgumentPromotion(arg);
  if (result.isInvalid()) return ExprError();
  paramType = result.get()->getType();
  return result;
}

// Otherwise, use the type that was written in the explicit cast.
assert(!arg->hasPlaceholderType())(static_cast <bool> (!arg->hasPlaceholderType()) ? void
 (0) : __assert_fail ("!arg->hasPlaceholderType()", "clang/lib/Sema/SemaExpr.cpp"
, 21116, __extension__ __PRETTY_FUNCTION__));
paramType = castArg->getTypeAsWritten();

// Copy-initialize a parameter of that type.
InitializedEntity entity =
  InitializedEntity::InitializeParameter(Context, paramType,
                                         /*consumed*/ false);
return PerformCopyInitialization(entity, callLoc, arg);
21124}

21126static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
Expr *orig = E;
unsigned diagID = diag::err_uncasted_use_of_unknown_any;
while (true) {
  E = E->IgnoreParenImpCasts();
  if (CallExpr *call = dyn_cast<CallExpr>(E)) {
    E = call->getCallee();
    diagID = diag::err_uncasted_call_of_unknown_any;
  } else {
    break;
  }
}

SourceLocation loc;
NamedDecl *d;
if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
  loc = ref->getLocation();
  d = ref->getDecl();
} else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
  loc = mem->getMemberLoc();
  d = mem->getMemberDecl();
} else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {
  diagID = diag::err_uncasted_call_of_unknown_any;
  loc = msg->getSelectorStartLoc();
  d = msg->getMethodDecl();
  if (!d) {
    S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
      << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
      << orig->getSourceRange();
    return ExprError();
  }
} else {
  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
    << E->getSourceRange();
  return ExprError();
}

S.Diag(loc, diagID) << d << orig->getSourceRange();

// Never recoverable.
return ExprError();
21167}

21169/// Check for operands with placeholder types and complain if found.
21170/// Returns ExprError() if there was an error and no recovery was possible.
21171ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
if (!Context.isDependenceAllowed()) {
  // C cannot handle TypoExpr nodes on either side of a binop because it
  // doesn't handle dependent types properly, so make sure any TypoExprs have
  // been dealt with before checking the operands.
  ExprResult Result = CorrectDelayedTyposInExpr(E);
  if (!Result.isUsable()) return ExprError();
  E = Result.get();
}

const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
if (!placeholderType) return E;

switch (placeholderType->getKind()) {

// Overloaded expressions.
case BuiltinType::Overload: {
  // Try to resolve a single function template specialization.
  // This is obligatory.
  ExprResult Result = E;
  if (ResolveAndFixSingleFunctionTemplateSpecialization(Result, false))
    return Result;

  // No guarantees that ResolveAndFixSingleFunctionTemplateSpecialization
  // leaves Result unchanged on failure.
  Result = E;
  if (resolveAndFixAddressOfSingleOverloadCandidate(Result))
    return Result;

  // If that failed, try to recover with a call.
  tryToRecoverWithCall(Result, PDiag(diag::err_ovl_unresolvable),
                       /*complain*/ true);
  return Result;
}

// Bound member functions.
case BuiltinType::BoundMember: {
  ExprResult result = E;
  const Expr *BME = E->IgnoreParens();
  PartialDiagnostic PD = PDiag(diag::err_bound_member_function);
  // Try to give a nicer diagnostic if it is a bound member that we recognize.
  if (isa<CXXPseudoDestructorExpr>(BME)) {
    PD = PDiag(diag::err_dtor_expr_without_call) << /*pseudo-destructor*/ 1;
  } else if (const auto *ME = dyn_cast<MemberExpr>(BME)) {
    if (ME->getMemberNameInfo().getName().getNameKind() ==
        DeclarationName::CXXDestructorName)
      PD = PDiag(diag::err_dtor_expr_without_call) << /*destructor*/ 0;
  }
  tryToRecoverWithCall(result, PD,
                       /*complain*/ true);
  return result;
}

// ARC unbridged casts.
case BuiltinType::ARCUnbridgedCast: {
  Expr *realCast = stripARCUnbridgedCast(E);
  diagnoseARCUnbridgedCast(realCast);
  return realCast;
}

// Expressions of unknown type.
case BuiltinType::UnknownAny:
  return diagnoseUnknownAnyExpr(*this, E);

// Pseudo-objects.
case BuiltinType::PseudoObject:
  return checkPseudoObjectRValue(E);

case BuiltinType::BuiltinFn: {
  // Accept __noop without parens by implicitly converting it to a call expr.
  auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
  if (DRE) {
    auto *FD = cast<FunctionDecl>(DRE->getDecl());
    unsigned BuiltinID = FD->getBuiltinID();
    if (BuiltinID == Builtin::BI__noop) {
      E = ImpCastExprToType(E, Context.getPointerType(FD->getType()),
                            CK_BuiltinFnToFnPtr)
              .get();
      return CallExpr::Create(Context, E, /*Args=*/{}, Context.IntTy,
                              VK_PRValue, SourceLocation(),
                              FPOptionsOverride());
    }

    if (Context.BuiltinInfo.isInStdNamespace(BuiltinID)) {
      // Any use of these other than a direct call is ill-formed as of C++20,
      // because they are not addressable functions. In earlier language
      // modes, warn and force an instantiation of the real body.
      Diag(E->getBeginLoc(),
           getLangOpts().CPlusPlus20
               ? diag::err_use_of_unaddressable_function
               : diag::warn_cxx20_compat_use_of_unaddressable_function);
      if (FD->isImplicitlyInstantiable()) {
        // Require a definition here because a normal attempt at
        // instantiation for a builtin will be ignored, and we won't try
        // again later. We assume that the definition of the template
        // precedes this use.
        InstantiateFunctionDefinition(E->getBeginLoc(), FD,
                                      /*Recursive=*/false,
                                      /*DefinitionRequired=*/true,
                                      /*AtEndOfTU=*/false);
      }
      // Produce a properly-typed reference to the function.
      CXXScopeSpec SS;
      SS.Adopt(DRE->getQualifierLoc());
      TemplateArgumentListInfo TemplateArgs;
      DRE->copyTemplateArgumentsInto(TemplateArgs);
      return BuildDeclRefExpr(
          FD, FD->getType(), VK_LValue, DRE->getNameInfo(),
          DRE->hasQualifier() ? &SS : nullptr, DRE->getFoundDecl(),
          DRE->getTemplateKeywordLoc(),
          DRE->hasExplicitTemplateArgs() ? &TemplateArgs : nullptr);
    }
  }

  Diag(E->getBeginLoc(), diag::err_builtin_fn_use);
  return ExprError();
}

case BuiltinType::IncompleteMatrixIdx:
  Diag(cast<MatrixSubscriptExpr>(E->IgnoreParens())
           ->getRowIdx()
           ->getBeginLoc(),
       diag::err_matrix_incomplete_index);
  return ExprError();

// Expressions of unknown type.
case BuiltinType::OMPArraySection:
  Diag(E->getBeginLoc(), diag::err_omp_array_section_use);
  return ExprError();

// Expressions of unknown type.
case BuiltinType::OMPArrayShaping:
  return ExprError(Diag(E->getBeginLoc(), diag::err_omp_array_shaping_use));

case BuiltinType::OMPIterator:
  return ExprError(Diag(E->getBeginLoc(), diag::err_omp_iterator_use));

// Everything else should be impossible.
21309#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
21311#include "clang/Basic/OpenCLImageTypes.def"
21312#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
21314#include "clang/Basic/OpenCLExtensionTypes.def"
21315#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
21317#include "clang/Basic/AArch64SVEACLETypes.def"
21318#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id:
21320#include "clang/Basic/PPCTypes.def"
21321#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21322#include "clang/Basic/RISCVVTypes.def"
21323#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
21324#include "clang/Basic/WebAssemblyReferenceTypes.def"
21325#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
21326#define PLACEHOLDER_TYPE(Id, SingletonId)
21327#include "clang/AST/BuiltinTypes.def"
  break;
}

llvm_unreachable("invalid placeholder type!")::llvm::llvm_unreachable_internal("invalid placeholder type!"
, "clang/lib/Sema/SemaExpr.cpp", 21331);
21332}

21334bool Sema::CheckCaseExpression(Expr *E) {
if (E->isTypeDependent())
  return true;
if (E->isValueDependent() || E->isIntegerConstantExpr(Context))
  return E->getType()->isIntegralOrEnumerationType();
return false;
21340}

21342/// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
21343ExprResult
21344Sema::ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&(static_cast <bool> ((Kind == tok::kw___objc_yes || Kind
 == tok::kw___objc_no) && "Unknown Objective-C Boolean value!"
) ? void (0) : __assert_fail ("(Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) && \"Unknown Objective-C Boolean value!\""
, "clang/lib/Sema/SemaExpr.cpp", 21346, __extension__ __PRETTY_FUNCTION__
))
       "Unknown Objective-C Boolean value!")(static_cast <bool> ((Kind == tok::kw___objc_yes || Kind
 == tok::kw___objc_no) && "Unknown Objective-C Boolean value!"
) ? void (0) : __assert_fail ("(Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) && \"Unknown Objective-C Boolean value!\""
, "clang/lib/Sema/SemaExpr.cpp", 21346, __extension__ __PRETTY_FUNCTION__
));
QualType BoolT = Context.ObjCBuiltinBoolTy;
if (!Context.getBOOLDecl()) {
  LookupResult Result(*this, &Context.Idents.get("BOOL"), OpLoc,
                      Sema::LookupOrdinaryName);
  if (LookupName(Result, getCurScope()) && Result.isSingleResult()) {
    NamedDecl *ND = Result.getFoundDecl();
    if (TypedefDecl *TD = dyn_cast<TypedefDecl>(ND))
      Context.setBOOLDecl(TD);
  }
}
if (Context.getBOOLDecl())
  BoolT = Context.getBOOLType();
return new (Context)
    ObjCBoolLiteralExpr(Kind == tok::kw___objc_yes, BoolT, OpLoc);
21361}

21363ExprResult Sema::ActOnObjCAvailabilityCheckExpr(
  llvm::ArrayRef<AvailabilitySpec> AvailSpecs, SourceLocation AtLoc,
  SourceLocation RParen) {
auto FindSpecVersion =
    [&](StringRef Platform) -> std::optional<VersionTuple> {
  auto Spec = llvm::find_if(AvailSpecs, [&](const AvailabilitySpec &Spec) {
    return Spec.getPlatform() == Platform;
  });
  // Transcribe the "ios" availability check to "maccatalyst" when compiling
  // for "maccatalyst" if "maccatalyst" is not specified.
  if (Spec == AvailSpecs.end() && Platform == "maccatalyst") {
    Spec = llvm::find_if(AvailSpecs, [&](const AvailabilitySpec &Spec) {
      return Spec.getPlatform() == "ios";
    });
  }
  if (Spec == AvailSpecs.end())
    return std::nullopt;
  return Spec->getVersion();
};

VersionTuple Version;
if (auto MaybeVersion =
        FindSpecVersion(Context.getTargetInfo().getPlatformName()))
  Version = *MaybeVersion;

// The use of `@available` in the enclosing context should be analyzed to
// warn when it's used inappropriately (i.e. not if(@available)).
if (FunctionScopeInfo *Context = getCurFunctionAvailabilityContext())
  Context->HasPotentialAvailabilityViolations = true;

return new (Context)
    ObjCAvailabilityCheckExpr(Version, AtLoc, RParen, Context.BoolTy);
21395}

21397ExprResult Sema::CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
                                  ArrayRef<Expr *> SubExprs, QualType T) {
if (!Context.getLangOpts().RecoveryAST)
  return ExprError();

if (isSFINAEContext())
  return ExprError();

if (T.isNull() || T->isUndeducedType() ||
    !Context.getLangOpts().RecoveryASTType)
  // We don't know the concrete type, fallback to dependent type.
  T = Context.DependentTy;

return RecoveryExpr::Create(Context, T, Begin, End, SubExprs);
21411}

←

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

→

1//===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===//
7//
8//  This file implements a semantic tree transformation that takes a given
9//  AST and rebuilds it, possibly transforming some nodes in the process.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H

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

46using namespace llvm::omp;

48namespace clang {
49using namespace sema;

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

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

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

121protected:
Sema &SemaRef;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Transform the given initializer.
///
/// By default, this routine transforms an initializer by stripping off the
/// semantic nodes added by initialization, then passing the result to
/// TransformExpr or TransformExprs.
///
/// \returns the transformed initializer.
ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);

/// Transform the given list of expressions.
///
/// This routine transforms a list of expressions by invoking
/// \c TransformExpr() for each subexpression. However, it also provides
/// support for variadic templates by expanding any pack expansions (if the
/// derived class permits such expansion) along the way. When pack expansions
/// are present, the number of outputs may not equal the number of inputs.
///
/// \param Inputs The set of expressions to be transformed.
///
/// \param NumInputs The number of expressions in \c Inputs.
///
/// \param IsCall If \c true, then this transform is being performed on
/// function-call arguments, and any arguments that should be dropped, will
/// be.
///
/// \param Outputs The transformed input expressions will be added to this
/// vector.
///
/// \param ArgChanged If non-NULL, will be set \c true if any argument changed
/// due to transformation.
///
/// \returns true if an error occurred, false otherwise.
bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
                    SmallVectorImpl<Expr *> &Outputs,
                    bool *ArgChanged = nullptr);

/// Transform the given declaration, which is referenced from a type
/// or expression.
///
/// By default, acts as the identity function on declarations, unless the
/// transformer has had to transform the declaration itself. Subclasses
/// may override this function to provide alternate behavior.
Decl *TransformDecl(SourceLocation Loc, Decl *D) {
  llvm::DenseMap<Decl *, Decl *>::iterator Known
    = TransformedLocalDecls.find(D);
  if (Known != TransformedLocalDecls.end())
    return Known->second;

  return D;
}

/// Transform the specified condition.
///
/// By default, this transforms the variable and expression and rebuilds
/// the condition.
Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
                                         Expr *Expr,
                                         Sema::ConditionKind Kind);

/// Transform the attributes associated with the given declaration and
/// place them on the new declaration.
///
/// By default, this operation does nothing. Subclasses may override this
/// behavior to transform attributes.
void transformAttrs(Decl *Old, Decl *New) { }

/// Note that a local declaration has been transformed by this
/// transformer.
///
/// Local declarations are typically transformed via a call to
/// TransformDefinition. However, in some cases (e.g., lambda expressions),
/// the transformer itself has to transform the declarations. This routine
/// can be overridden by a subclass that keeps track of such mappings.
void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> New) {
  assert(New.size() == 1 &&(static_cast <bool> (New.size() == 1 && "must override transformedLocalDecl if performing pack expansion"
) ? void (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 503, __extension__ __PRETTY_FUNCTION__
))
         "must override transformedLocalDecl if performing pack expansion")(static_cast <bool> (New.size() == 1 && "must override transformedLocalDecl if performing pack expansion"
) ? void (0) : __assert_fail ("New.size() == 1 && \"must override transformedLocalDecl if performing pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 503, __extension__ __PRETTY_FUNCTION__
));
  TransformedLocalDecls[Old] = New.front();
}

/// Transform the definition of the given declaration.
///
/// By default, invokes TransformDecl() to transform the declaration.
/// Subclasses may override this function to provide alternate behavior.
Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
  return getDerived().TransformDecl(Loc, D);
}

/// Transform the given declaration, which was the first part of a
/// nested-name-specifier in a member access expression.
///
/// This specific declaration transformation only applies to the first
/// identifier in a nested-name-specifier of a member access expression, e.g.,
/// the \c T in \c x->T::member
///
/// By default, invokes TransformDecl() to transform the declaration.
/// Subclasses may override this function to provide alternate behavior.
NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
  return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
}

/// Transform the set of declarations in an OverloadExpr.
bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
                                LookupResult &R);

/// Transform the given nested-name-specifier with source-location
/// information.
///
/// By default, transforms all of the types and declarations within the
/// nested-name-specifier. Subclasses may override this function to provide
/// alternate behavior.
NestedNameSpecifierLoc
TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
                                QualType ObjectType = QualType(),
                                NamedDecl *FirstQualifierInScope = nullptr);

/// Transform the given declaration name.
///
/// By default, transforms the types of conversion function, constructor,
/// and destructor names and then (if needed) rebuilds the declaration name.
/// Identifiers and selectors are returned unmodified. Subclasses may
/// override this function to provide alternate behavior.
DeclarationNameInfo
TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);

bool TransformRequiresExprRequirements(ArrayRef<concepts::Requirement *> Reqs,
    llvm::SmallVectorImpl<concepts::Requirement *> &Transformed);
concepts::TypeRequirement *
TransformTypeRequirement(concepts::TypeRequirement *Req);
concepts::ExprRequirement *
TransformExprRequirement(concepts::ExprRequirement *Req);
concepts::NestedRequirement *
TransformNestedRequirement(concepts::NestedRequirement *Req);

/// Transform the given template name.
///
/// \param SS The nested-name-specifier that qualifies the template
/// name. This nested-name-specifier must already have been transformed.
///
/// \param Name The template name to transform.
///
/// \param NameLoc The source location of the template name.
///
/// \param ObjectType If we're translating a template name within a member
/// access expression, this is the type of the object whose member template
/// is being referenced.
///
/// \param FirstQualifierInScope If the first part of a nested-name-specifier
/// also refers to a name within the current (lexical) scope, this is the
/// declaration it refers to.
///
/// By default, transforms the template name by transforming the declarations
/// and nested-name-specifiers that occur within the template name.
/// Subclasses may override this function to provide alternate behavior.
TemplateName
TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
                      SourceLocation NameLoc,
                      QualType ObjectType = QualType(),
                      NamedDecl *FirstQualifierInScope = nullptr,
                      bool AllowInjectedClassName = false);

/// Transform the given template argument.
///
/// By default, this operation transforms the type, expression, or
/// declaration stored within the template argument and constructs a
/// new template argument from the transformed result. Subclasses may
/// override this function to provide alternate behavior.
///
/// Returns true if there was an error.
bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
                               TemplateArgumentLoc &Output,
                               bool Uneval = false);

/// Transform the given set of template arguments.
///
/// By default, this operation transforms all of the template arguments
/// in the input set using \c TransformTemplateArgument(), and appends
/// the transformed arguments to the output list.
///
/// Note that this overload of \c TransformTemplateArguments() is merely
/// a convenience function. Subclasses that wish to override this behavior
/// should override the iterator-based member template version.
///
/// \param Inputs The set of template arguments to be transformed.
///
/// \param NumInputs The number of template arguments in \p Inputs.
///
/// \param Outputs The set of transformed template arguments output by this
/// routine.
///
/// Returns true if an error occurred.
bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
                                unsigned NumInputs,
                                TemplateArgumentListInfo &Outputs,
                                bool Uneval = false) {
  return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
                                    Uneval);
}

/// Transform the given set of template arguments.
///
/// By default, this operation transforms all of the template arguments
/// in the input set using \c TransformTemplateArgument(), and appends
/// the transformed arguments to the output list.
///
/// \param First An iterator to the first template argument.
///
/// \param Last An iterator one step past the last template argument.
///
/// \param Outputs The set of transformed template arguments output by this
/// routine.
///
/// Returns true if an error occurred.
template<typename InputIterator>
bool TransformTemplateArguments(InputIterator First,
                                InputIterator Last,
                                TemplateArgumentListInfo &Outputs,
                                bool Uneval = false);

/// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
void InventTemplateArgumentLoc(const TemplateArgument &Arg,
                               TemplateArgumentLoc &ArgLoc);

/// Fakes up a TypeSourceInfo for a type.
TypeSourceInfo *InventTypeSourceInfo(QualType T) {
  return SemaRef.Context.getTrivialTypeSourceInfo(T,
                     getDerived().getBaseLocation());
}

656#define ABSTRACT_TYPELOC(CLASS, PARENT)
657#define TYPELOC(CLASS, PARENT)                                   \
QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
659#include "clang/AST/TypeLocNodes.def"

QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                       TemplateTypeParmTypeLoc TL,
                                       bool SuppressObjCLifetime);
QualType
TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmPackTypeLoc TL,
                                       bool SuppressObjCLifetime);

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

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

StmtResult TransformSEHHandler(Stmt *Handler);

QualType
TransformTemplateSpecializationType(TypeLocBuilder &TLB,
                                    TemplateSpecializationTypeLoc TL,
                                    TemplateName Template);

QualType
TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                                    DependentTemplateSpecializationTypeLoc TL,
                                             TemplateName Template,
                                             CXXScopeSpec &SS);

QualType TransformDependentTemplateSpecializationType(
    TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
    NestedNameSpecifierLoc QualifierLoc);

/// Transforms the parameters of a function type into the
/// given vectors.
///
/// The result vectors should be kept in sync; null entries in the
/// variables vector are acceptable.
///
/// LastParamTransformed, if non-null, will be set to the index of the last
/// parameter on which transfromation was started. In the event of an error,
/// this will contain the parameter which failed to instantiate.
///
/// Return true on error.
bool TransformFunctionTypeParams(
    SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
    const QualType *ParamTypes,
    const FunctionProtoType::ExtParameterInfo *ParamInfos,
    SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
    Sema::ExtParameterInfoBuilder &PInfos, unsigned *LastParamTransformed);

bool TransformFunctionTypeParams(
    SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
    const QualType *ParamTypes,
    const FunctionProtoType::ExtParameterInfo *ParamInfos,
    SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
    Sema::ExtParameterInfoBuilder &PInfos) {
  return getDerived().TransformFunctionTypeParams(
      Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos, nullptr);
}

/// Transforms the parameters of a requires expresison into the given vectors.
///
/// The result vectors should be kept in sync; null entries in the
/// variables vector are acceptable.
///
/// Returns an unset ExprResult on success.  Returns an ExprResult the 'not
/// satisfied' RequiresExpr if subsitution failed, OR an ExprError, both of
/// which are cases where transformation shouldn't continue.
ExprResult TransformRequiresTypeParams(
    SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE,
    RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params,
    SmallVectorImpl<QualType> &PTypes,
    SmallVectorImpl<ParmVarDecl *> &TransParams,
    Sema::ExtParameterInfoBuilder &PInfos) {
  if (getDerived().TransformFunctionTypeParams(
          KWLoc, Params, /*ParamTypes=*/nullptr,
          /*ParamInfos=*/nullptr, PTypes, &TransParams, PInfos))
    return ExprError();

  return ExprResult{};
}

/// Transforms a single function-type parameter.  Return null
/// on error.
///
/// \param indexAdjustment - A number to add to the parameter's
///   scope index;  can be negative
ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                        int indexAdjustment,
                                        std::optional<unsigned> NumExpansions,
                                        bool ExpectParameterPack);

/// Transform the body of a lambda-expression.
StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
/// Alternative implementation of TransformLambdaBody that skips transforming
/// the body.
StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);

QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);

StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);

TemplateParameterList *TransformTemplateParameterList(
      TemplateParameterList *TPL) {
  return TPL;
}

ExprResult TransformAddressOfOperand(Expr *E);

ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
                                              bool IsAddressOfOperand,
                                              TypeSourceInfo **RecoveryTSI);

ExprResult TransformParenDependentScopeDeclRefExpr(
    ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
    TypeSourceInfo **RecoveryTSI);

StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);

786// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
787// amount of stack usage with clang.
788#define STMT(Node, Parent)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
StmtResult Transform##Node(Node *S);
791#define VALUESTMT(Node, Parent)                   \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
794#define EXPR(Node, Parent)                        \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
ExprResult Transform##Node(Node *E);
797#define ABSTRACT_STMT(Stmt)
798#include "clang/AST/StmtNodes.inc"

800#define GEN_CLANG_CLAUSE_CLASS
801#define CLAUSE_CLASS(Enum, Str, Class)                                         \
LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))                                                      \
OMPClause *Transform##Class(Class *S);
804#include "llvm/Frontend/OpenMP/OMP.inc"

/// Build a new qualified type given its unqualified type and type location.
///
/// By default, this routine adds type qualifiers only to types that can
/// have qualifiers, and silently suppresses those qualifiers that are not
/// permitted. Subclasses may override this routine to provide different
/// behavior.
QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);

/// Build a new pointer type given its pointee type.
///
/// By default, performs semantic analysis when building the pointer type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);

/// Build a new block pointer type given its pointee type.
///
/// By default, performs semantic analysis when building the block pointer
/// type. Subclasses may override this routine to provide different behavior.
QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);

/// Build a new reference type given the type it references.
///
/// By default, performs semantic analysis when building the
/// reference type. Subclasses may override this routine to provide
/// different behavior.
///
/// \param LValue whether the type was written with an lvalue sigil
/// or an rvalue sigil.
QualType RebuildReferenceType(QualType ReferentType,
                              bool LValue,
                              SourceLocation Sigil);

/// Build a new member pointer type given the pointee type and the
/// class type it refers into.
///
/// By default, performs semantic analysis when building the member pointer
/// type. Subclasses may override this routine to provide different behavior.
QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
                                  SourceLocation Sigil);

QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                                  SourceLocation ProtocolLAngleLoc,
                                  ArrayRef<ObjCProtocolDecl *> Protocols,
                                  ArrayRef<SourceLocation> ProtocolLocs,
                                  SourceLocation ProtocolRAngleLoc);

/// Build an Objective-C object type.
///
/// By default, performs semantic analysis when building the object type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildObjCObjectType(QualType BaseType,
                               SourceLocation Loc,
                               SourceLocation TypeArgsLAngleLoc,
                               ArrayRef<TypeSourceInfo *> TypeArgs,
                               SourceLocation TypeArgsRAngleLoc,
                               SourceLocation ProtocolLAngleLoc,
                               ArrayRef<ObjCProtocolDecl *> Protocols,
                               ArrayRef<SourceLocation> ProtocolLocs,
                               SourceLocation ProtocolRAngleLoc);

/// Build a new Objective-C object pointer type given the pointee type.
///
/// By default, directly builds the pointer type, with no additional semantic
/// analysis.
QualType RebuildObjCObjectPointerType(QualType PointeeType,
                                      SourceLocation Star);

/// Build a new array type given the element type, size
/// modifier, size of the array (if known), size expression, and index type
/// qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
/// Also by default, all of the other Rebuild*Array
QualType RebuildArrayType(QualType ElementType,
                          ArrayType::ArraySizeModifier SizeMod,
                          const llvm::APInt *Size,
                          Expr *SizeExpr,
                          unsigned IndexTypeQuals,
                          SourceRange BracketsRange);

/// Build a new constant array type given the element type, size
/// modifier, (known) size of the array, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildConstantArrayType(QualType ElementType,
                                  ArrayType::ArraySizeModifier SizeMod,
                                  const llvm::APInt &Size,
                                  Expr *SizeExpr,
                                  unsigned IndexTypeQuals,
                                  SourceRange BracketsRange);

/// Build a new incomplete array type given the element type, size
/// modifier, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildIncompleteArrayType(QualType ElementType,
                                    ArrayType::ArraySizeModifier SizeMod,
                                    unsigned IndexTypeQuals,
                                    SourceRange BracketsRange);

/// Build a new variable-length array type given the element type,
/// size modifier, size expression, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildVariableArrayType(QualType ElementType,
                                  ArrayType::ArraySizeModifier SizeMod,
                                  Expr *SizeExpr,
                                  unsigned IndexTypeQuals,
                                  SourceRange BracketsRange);

/// Build a new dependent-sized array type given the element type,
/// size modifier, size expression, and index type qualifiers.
///
/// By default, performs semantic analysis when building the array type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentSizedArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                        Expr *SizeExpr,
                                        unsigned IndexTypeQuals,
                                        SourceRange BracketsRange);

/// Build a new vector type given the element type and
/// number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
                           VectorType::VectorKind VecKind);

/// Build a new potentially dependently-sized extended vector type
/// given the element type and number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
                                         SourceLocation AttributeLoc,
                                         VectorType::VectorKind);

/// Build a new extended vector type given the element type and
/// number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
                              SourceLocation AttributeLoc);

/// Build a new potentially dependently-sized extended vector type
/// given the element type and number of elements.
///
/// By default, performs semantic analysis when building the vector type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDependentSizedExtVectorType(QualType ElementType,
                                            Expr *SizeExpr,
                                            SourceLocation AttributeLoc);

/// Build a new matrix type given the element type and dimensions.
QualType RebuildConstantMatrixType(QualType ElementType, unsigned NumRows,
                                   unsigned NumColumns);

/// Build a new matrix type given the type and dependently-defined
/// dimensions.
QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
                                         Expr *ColumnExpr,
                                         SourceLocation AttributeLoc);

/// Build a new DependentAddressSpaceType or return the pointee
/// type variable with the correct address space (retrieved from
/// AddrSpaceExpr) applied to it. The former will be returned in cases
/// where the address space remains dependent.
///
/// By default, performs semantic analysis when building the type with address
/// space applied. Subclasses may override this routine to provide different
/// behavior.
QualType RebuildDependentAddressSpaceType(QualType PointeeType,
                                          Expr *AddrSpaceExpr,
                                          SourceLocation AttributeLoc);

/// Build a new function type.
///
/// By default, performs semantic analysis when building the function type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildFunctionProtoType(QualType T,
                                  MutableArrayRef<QualType> ParamTypes,
                                  const FunctionProtoType::ExtProtoInfo &EPI);

/// Build a new unprototyped function type.
QualType RebuildFunctionNoProtoType(QualType ResultType);

/// Rebuild an unresolved typename type, given the decl that
/// the UnresolvedUsingTypenameDecl was transformed to.
QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);

/// Build a new type found via an alias.
QualType RebuildUsingType(UsingShadowDecl *Found, QualType Underlying) {
  return SemaRef.Context.getUsingType(Found, Underlying);
}

/// Build a new typedef type.
QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
  return SemaRef.Context.getTypeDeclType(Typedef);
}

/// Build a new MacroDefined type.
QualType RebuildMacroQualifiedType(QualType T,
                                   const IdentifierInfo *MacroII) {
  return SemaRef.Context.getMacroQualifiedType(T, MacroII);
}

/// Build a new class/struct/union type.
QualType RebuildRecordType(RecordDecl *Record) {
  return SemaRef.Context.getTypeDeclType(Record);
}

/// Build a new Enum type.
QualType RebuildEnumType(EnumDecl *Enum) {
  return SemaRef.Context.getTypeDeclType(Enum);
}

/// Build a new typeof(expr) type.
///
/// By default, performs semantic analysis when building the typeof type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc,
                               TypeOfKind Kind);

/// Build a new typeof(type) type.
///
/// By default, builds a new TypeOfType with the given underlying type.
QualType RebuildTypeOfType(QualType Underlying, TypeOfKind Kind);

/// Build a new unary transform type.
QualType RebuildUnaryTransformType(QualType BaseType,
                                   UnaryTransformType::UTTKind UKind,
                                   SourceLocation Loc);

/// Build a new C++11 decltype type.
///
/// By default, performs semantic analysis when building the decltype type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);

/// Build a new C++11 auto type.
///
/// By default, builds a new AutoType with the given deduced type.
QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword,
                         ConceptDecl *TypeConstraintConcept,
                         ArrayRef<TemplateArgument> TypeConstraintArgs) {
  // Note, IsDependent is always false here: we implicitly convert an 'auto'
  // which has been deduced to a dependent type into an undeduced 'auto', so
  // that we'll retry deduction after the transformation.
  return SemaRef.Context.getAutoType(Deduced, Keyword,
                                     /*IsDependent*/ false, /*IsPack=*/false,
                                     TypeConstraintConcept,
                                     TypeConstraintArgs);
}

/// By default, builds a new DeducedTemplateSpecializationType with the given
/// deduced type.
QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
    QualType Deduced) {
  return SemaRef.Context.getDeducedTemplateSpecializationType(
      Template, Deduced, /*IsDependent*/ false);
}

/// Build a new template specialization type.
///
/// By default, performs semantic analysis when building the template
/// specialization type. Subclasses may override this routine to provide
/// different behavior.
QualType RebuildTemplateSpecializationType(TemplateName Template,
                                           SourceLocation TemplateLoc,
                                           TemplateArgumentListInfo &Args);

/// Build a new parenthesized type.
///
/// By default, builds a new ParenType type from the inner type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildParenType(QualType InnerType) {
  return SemaRef.BuildParenType(InnerType);
}

/// Build a new qualified name type.
///
/// By default, builds a new ElaboratedType type from the keyword,
/// the nested-name-specifier and the named type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildElaboratedType(SourceLocation KeywordLoc,
                               ElaboratedTypeKeyword Keyword,
                               NestedNameSpecifierLoc QualifierLoc,
                               QualType Named) {
  return SemaRef.Context.getElaboratedType(Keyword,
                                       QualifierLoc.getNestedNameSpecifier(),
                                           Named);
}

/// Build a new typename type that refers to a template-id.
///
/// By default, builds a new DependentNameType type from the
/// nested-name-specifier and the given type. Subclasses may override
/// this routine to provide different behavior.
QualType RebuildDependentTemplateSpecializationType(
                                        ElaboratedTypeKeyword Keyword,
                                        NestedNameSpecifierLoc QualifierLoc,
                                        SourceLocation TemplateKWLoc,
                                        const IdentifierInfo *Name,
                                        SourceLocation NameLoc,
                                        TemplateArgumentListInfo &Args,
                                        bool AllowInjectedClassName) {
  // Rebuild the template name.
  // TODO: avoid TemplateName abstraction
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  TemplateName InstName = getDerived().RebuildTemplateName(
      SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
      AllowInjectedClassName);

  if (InstName.isNull())
    return QualType();

  // If it's still dependent, make a dependent specialization.
  if (InstName.getAsDependentTemplateName())
    return SemaRef.Context.getDependentTemplateSpecializationType(
        Keyword, QualifierLoc.getNestedNameSpecifier(), Name,
        Args.arguments());

  // Otherwise, make an elaborated type wrapping a non-dependent
  // specialization.
  QualType T =
      getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
  if (T.isNull())
    return QualType();
  return SemaRef.Context.getElaboratedType(
      Keyword, QualifierLoc.getNestedNameSpecifier(), T);
}

/// Build a new typename type that refers to an identifier.
///
/// By default, performs semantic analysis when building the typename type
/// (or elaborated type). Subclasses may override this routine to provide
/// different behavior.
QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
                                  SourceLocation KeywordLoc,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  const IdentifierInfo *Id,
                                  SourceLocation IdLoc,
                                  bool DeducedTSTContext) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
    // If the name is still dependent, just build a new dependent name type.
    if (!SemaRef.computeDeclContext(SS))
      return SemaRef.Context.getDependentNameType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                                  Id);
  }

  if (Keyword == ETK_None || Keyword == ETK_Typename) {
    return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
                                     *Id, IdLoc, DeducedTSTContext);
  }

  TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);

  // We had a dependent elaborated-type-specifier that has been transformed
  // into a non-dependent elaborated-type-specifier. Find the tag we're
  // referring to.
  LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
  DeclContext *DC = SemaRef.computeDeclContext(SS, false);
  if (!DC)
    return QualType();

  if (SemaRef.RequireCompleteDeclContext(SS, DC))
    return QualType();

  TagDecl *Tag = nullptr;
  SemaRef.LookupQualifiedName(Result, DC);
  switch (Result.getResultKind()) {
    case LookupResult::NotFound:
    case LookupResult::NotFoundInCurrentInstantiation:
      break;

    case LookupResult::Found:
      Tag = Result.getAsSingle<TagDecl>();
      break;

    case LookupResult::FoundOverloaded:
    case LookupResult::FoundUnresolvedValue:
      llvm_unreachable("Tag lookup cannot find non-tags")::llvm::llvm_unreachable_internal("Tag lookup cannot find non-tags"
, "clang/lib/Sema/TreeTransform.h", 1198);

    case LookupResult::Ambiguous:
      // Let the LookupResult structure handle ambiguities.
      return QualType();
  }

  if (!Tag) {
    // Check where the name exists but isn't a tag type and use that to emit
    // better diagnostics.
    LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
    SemaRef.LookupQualifiedName(Result, DC);
    switch (Result.getResultKind()) {
      case LookupResult::Found:
      case LookupResult::FoundOverloaded:
      case LookupResult::FoundUnresolvedValue: {
        NamedDecl *SomeDecl = Result.getRepresentativeDecl();
        Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
        SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
                                                             << NTK << Kind;
        SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
        break;
      }
      default:
        SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
            << Kind << Id << DC << QualifierLoc.getSourceRange();
        break;
    }
    return QualType();
  }

  if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
                                            IdLoc, Id)) {
    SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
    SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
    return QualType();
  }

  // Build the elaborated-type-specifier type.
  QualType T = SemaRef.Context.getTypeDeclType(Tag);
  return SemaRef.Context.getElaboratedType(Keyword,
                                       QualifierLoc.getNestedNameSpecifier(),
                                           T);
}

/// Build a new pack expansion type.
///
/// By default, builds a new PackExpansionType type from the given pattern.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange,
                                  SourceLocation EllipsisLoc,
                                  std::optional<unsigned> NumExpansions) {
  return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
                                      NumExpansions);
}

/// Build a new atomic type given its value type.
///
/// By default, performs semantic analysis when building the atomic type.
/// Subclasses may override this routine to provide different behavior.
QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);

/// Build a new pipe type given its value type.
QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
                         bool isReadPipe);

/// Build a bit-precise int given its value type.
QualType RebuildBitIntType(bool IsUnsigned, unsigned NumBits,
                           SourceLocation Loc);

/// Build a dependent bit-precise int given its value type.
QualType RebuildDependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr,
                                    SourceLocation Loc);

/// Build a new template name given a nested name specifier, a flag
/// indicating whether the "template" keyword was provided, and the template
/// that the template name refers to.
///
/// By default, builds the new template name directly. Subclasses may override
/// this routine to provide different behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 bool TemplateKW,
                                 TemplateDecl *Template);

/// Build a new template name given a nested name specifier and the
/// name that is referred to as a template.
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 const IdentifierInfo &Name,
                                 SourceLocation NameLoc, QualType ObjectType,
                                 NamedDecl *FirstQualifierInScope,
                                 bool AllowInjectedClassName);

/// Build a new template name given a nested name specifier and the
/// overloaded operator name that is referred to as a template.
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 OverloadedOperatorKind Operator,
                                 SourceLocation NameLoc, QualType ObjectType,
                                 bool AllowInjectedClassName);

/// Build a new template name given a template template parameter pack
/// and the
///
/// By default, performs semantic analysis to determine whether the name can
/// be resolved to a specific template, then builds the appropriate kind of
/// template name. Subclasses may override this routine to provide different
/// behavior.
TemplateName RebuildTemplateName(const TemplateArgument &ArgPack,
                                 Decl *AssociatedDecl, unsigned Index,
                                 bool Final) {
  return getSema().Context.getSubstTemplateTemplateParmPack(
      ArgPack, AssociatedDecl, Index, Final);
}

/// Build a new compound statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
                                     MultiStmtArg Statements,
                                     SourceLocation RBraceLoc,
                                     bool IsStmtExpr) {
  return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
                                     IsStmtExpr);
}

/// Build a new case statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
                                 Expr *LHS,
                                 SourceLocation EllipsisLoc,
                                 Expr *RHS,
                                 SourceLocation ColonLoc) {
  return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
                                 ColonLoc);
}

/// Attach the body to a new case statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
  getSema().ActOnCaseStmtBody(S, Body);
  return S;
}

/// Build a new default statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
                                    SourceLocation ColonLoc,
                                    Stmt *SubStmt) {
  return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
                                    /*CurScope=*/nullptr);
}

/// Build a new label statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
                            SourceLocation ColonLoc, Stmt *SubStmt) {
  return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
}

/// Build a new attributed statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
                                 ArrayRef<const Attr *> Attrs,
                                 Stmt *SubStmt) {
  return SemaRef.BuildAttributedStmt(AttrLoc, Attrs, SubStmt);
}

/// Build a new "if" statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildIfStmt(SourceLocation IfLoc, IfStatementKind Kind,
                         SourceLocation LParenLoc, Sema::ConditionResult Cond,
                         SourceLocation RParenLoc, Stmt *Init, Stmt *Then,
                         SourceLocation ElseLoc, Stmt *Else) {
  return getSema().ActOnIfStmt(IfLoc, Kind, LParenLoc, Init, Cond, RParenLoc,
                               Then, ElseLoc, Else);
}

/// Start building a new switch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
                                  SourceLocation LParenLoc, Stmt *Init,
                                  Sema::ConditionResult Cond,
                                  SourceLocation RParenLoc) {
  return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond,
                                          RParenLoc);
}

/// Attach the body to the switch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
                                 Stmt *Switch, Stmt *Body) {
  return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
}

/// Build a new while statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
                            Sema::ConditionResult Cond,
                            SourceLocation RParenLoc, Stmt *Body) {
  return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body);
}

/// Build a new do-while statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
                         SourceLocation WhileLoc, SourceLocation LParenLoc,
                         Expr *Cond, SourceLocation RParenLoc) {
  return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
                               Cond, RParenLoc);
}

/// Build a new for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
                          Stmt *Init, Sema::ConditionResult Cond,
                          Sema::FullExprArg Inc, SourceLocation RParenLoc,
                          Stmt *Body) {
  return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
                                Inc, RParenLoc, Body);
}

/// Build a new goto statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
                           LabelDecl *Label) {
  return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
}

/// Build a new indirect goto statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
                                   SourceLocation StarLoc,
                                   Expr *Target) {
  return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
}

/// Build a new return statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
  return getSema().BuildReturnStmt(ReturnLoc, Result);
}

/// Build a new declaration statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
                           SourceLocation StartLoc, SourceLocation EndLoc) {
  Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
  return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
}

/// Build a new inline asm statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                             bool IsVolatile, unsigned NumOutputs,
                             unsigned NumInputs, IdentifierInfo **Names,
                             MultiExprArg Constraints, MultiExprArg Exprs,
                             Expr *AsmString, MultiExprArg Clobbers,
                             unsigned NumLabels,
                             SourceLocation RParenLoc) {
  return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
                                   NumInputs, Names, Constraints, Exprs,
                                   AsmString, Clobbers, NumLabels, RParenLoc);
}

/// Build a new MS style inline asm statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                            ArrayRef<Token> AsmToks,
                            StringRef AsmString,
                            unsigned NumOutputs, unsigned NumInputs,
                            ArrayRef<StringRef> Constraints,
                            ArrayRef<StringRef> Clobbers,
                            ArrayRef<Expr*> Exprs,
                            SourceLocation EndLoc) {
  return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
                                  NumOutputs, NumInputs,
                                  Constraints, Clobbers, Exprs, EndLoc);
}

/// Build a new co_return statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
                               bool IsImplicit) {
  return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
}

/// Build a new co_await expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand,
                              UnresolvedLookupExpr *OpCoawaitLookup,
                              bool IsImplicit) {
  // This function rebuilds a coawait-expr given its operator.
  // For an explicit coawait-expr, the rebuild involves the full set
  // of transformations performed by BuildUnresolvedCoawaitExpr(),
  // including calling await_transform().
  // For an implicit coawait-expr, we need to rebuild the "operator
  // coawait" but not await_transform(), so use BuildResolvedCoawaitExpr().
  // This mirrors how the implicit CoawaitExpr is originally created
  // in Sema::ActOnCoroutineBodyStart().
  if (IsImplicit) {
    ExprResult Suspend = getSema().BuildOperatorCoawaitCall(
        CoawaitLoc, Operand, OpCoawaitLookup);
    if (Suspend.isInvalid())
      return ExprError();
    return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Operand,
                                              Suspend.get(), true);
  }

  return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Operand,
                                              OpCoawaitLookup);
}

/// Build a new co_await expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
                                       Expr *Result,
                                       UnresolvedLookupExpr *Lookup) {
  return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
}

/// Build a new co_yield expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
  return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
}

StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
  return getSema().BuildCoroutineBodyStmt(Args);
}

/// Build a new Objective-C \@try statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
                                      Stmt *TryBody,
                                      MultiStmtArg CatchStmts,
                                      Stmt *Finally) {
  return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
                                      Finally);
}

/// Rebuild an Objective-C exception declaration.
///
/// By default, performs semantic analysis to build the new declaration.
/// Subclasses may override this routine to provide different behavior.
VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
                                  TypeSourceInfo *TInfo, QualType T) {
  return getSema().BuildObjCExceptionDecl(TInfo, T,
                                          ExceptionDecl->getInnerLocStart(),
                                          ExceptionDecl->getLocation(),
                                          ExceptionDecl->getIdentifier());
}

/// Build a new Objective-C \@catch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
                                        SourceLocation RParenLoc,
                                        VarDecl *Var,
                                        Stmt *Body) {
  return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
                                        Var, Body);
}

/// Build a new Objective-C \@finally statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
                                          Stmt *Body) {
  return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
}

/// Build a new Objective-C \@throw statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
                                        Expr *Operand) {
  return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
}

/// Build a new OpenMP Canonical loop.
///
/// Ensures that the outermost loop in @p LoopStmt is wrapped by a
/// OMPCanonicalLoop.
StmtResult RebuildOMPCanonicalLoop(Stmt *LoopStmt) {
  return getSema().ActOnOpenMPCanonicalLoop(LoopStmt);
}

/// Build a new OpenMP executable directive.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
                                         DeclarationNameInfo DirName,
                                         OpenMPDirectiveKind CancelRegion,
                                         ArrayRef<OMPClause *> Clauses,
                                         Stmt *AStmt, SourceLocation StartLoc,
                                         SourceLocation EndLoc) {
  return getSema().ActOnOpenMPExecutableDirective(
      Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
}

/// Build a new OpenMP 'if' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
                              Expr *Condition, SourceLocation StartLoc,
                              SourceLocation LParenLoc,
                              SourceLocation NameModifierLoc,
                              SourceLocation ColonLoc,
                              SourceLocation EndLoc) {
  return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
                                       LParenLoc, NameModifierLoc, ColonLoc,
                                       EndLoc);
}

/// Build a new OpenMP 'final' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
                                          EndLoc);
}

/// Build a new OpenMP 'num_threads' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
                                               LParenLoc, EndLoc);
}

/// Build a new OpenMP 'safelen' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'simdlen' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
}

OMPClause *RebuildOMPSizesClause(ArrayRef<Expr *> Sizes,
                                 SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSizesClause(Sizes, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'full' clause.
OMPClause *RebuildOMPFullClause(SourceLocation StartLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFullClause(StartLoc, EndLoc);
}

/// Build a new OpenMP 'partial' clause.
OMPClause *RebuildOMPPartialClause(Expr *Factor, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPartialClause(Factor, StartLoc, LParenLoc,
                                            EndLoc);
}

/// Build a new OpenMP 'allocator' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'collapse' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'default' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
                                            StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'proc_bind' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPProcBindClause(ProcBindKind Kind,
                                    SourceLocation KindKwLoc,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
                                             StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'schedule' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPScheduleClause(
    OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
    OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
    SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPScheduleClause(
      M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
      CommaLoc, EndLoc);
}

/// Build a new OpenMP 'ordered' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
                                   SourceLocation EndLoc,
                                   SourceLocation LParenLoc, Expr *Num) {
  return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
}

/// Build a new OpenMP 'private' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
                                            EndLoc);
}

/// Build a new OpenMP 'firstprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
                                        SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
                                                 EndLoc);
}

/// Build a new OpenMP 'lastprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
                                       OpenMPLastprivateModifier LPKind,
                                       SourceLocation LPKindLoc,
                                       SourceLocation ColonLoc,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPLastprivateClause(
      VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'shared' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPReductionClause(
    ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
    SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation ModifierLoc, SourceLocation ColonLoc,
    SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
    const DeclarationNameInfo &ReductionId,
    ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPReductionClause(
      VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
      ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'task_reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPTaskReductionClause(
    ArrayRef<Expr *> VarList, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
    CXXScopeSpec &ReductionIdScopeSpec,
    const DeclarationNameInfo &ReductionId,
    ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPTaskReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'in_reduction' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
                            SourceLocation LParenLoc, SourceLocation ColonLoc,
                            SourceLocation EndLoc,
                            CXXScopeSpec &ReductionIdScopeSpec,
                            const DeclarationNameInfo &ReductionId,
                            ArrayRef<Expr *> UnresolvedReductions) {
  return getSema().ActOnOpenMPInReductionClause(
      VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
      ReductionId, UnresolvedReductions);
}

/// Build a new OpenMP 'linear' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  OpenMPLinearClauseKind Modifier,
                                  SourceLocation ModifierLoc,
                                  SourceLocation ColonLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
                                           Modifier, ModifierLoc, ColonLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'aligned' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
                                   SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation ColonLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
                                            LParenLoc, ColonLoc, EndLoc);
}

/// Build a new OpenMP 'copyin' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'copyprivate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
                                                EndLoc);
}

/// Build a new OpenMP 'flush' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
                                 SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
                                          EndLoc);
}

/// Build a new OpenMP 'depobj' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDepobjClause(Depobj, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'depend' pseudo clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDependClause(OMPDependClause::DependDataTy Data,
                                  Expr *DepModifier, ArrayRef<Expr *> VarList,
                                  SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDependClause(Data, DepModifier, VarList,
                                           StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'device' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
                                  Expr *Device, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation ModifierLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDeviceClause(Modifier, Device, StartLoc,
                                           LParenLoc, ModifierLoc, EndLoc);
}

/// Build a new OpenMP 'map' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPMapClause(
    Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
    ArrayRef<SourceLocation> MapTypeModifiersLoc,
    CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId,
    OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
    SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
    const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPMapClause(
      IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
      MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
      ColonLoc, VarList, Locs,
      /*NoDiagnose=*/false, UnresolvedMappers);
}

/// Build a new OpenMP 'allocate' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAllocateClause(Expr *Allocate, ArrayRef<Expr *> VarList,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ColonLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAllocateClause(Allocate, VarList, StartLoc,
                                             LParenLoc, ColonLoc, EndLoc);
}

/// Build a new OpenMP 'num_teams' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'thread_limit' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
                                                LParenLoc, EndLoc);
}

/// Build a new OpenMP 'priority' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'grainsize' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier,
                                     Expr *Device, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation ModifierLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPGrainsizeClause(Modifier, Device, StartLoc,
                                              LParenLoc, ModifierLoc, EndLoc);
}

/// Build a new OpenMP 'num_tasks' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier,
                                    Expr *NumTasks, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ModifierLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNumTasksClause(Modifier, NumTasks, StartLoc,
                                             LParenLoc, ModifierLoc, EndLoc);
}

/// Build a new OpenMP 'hint' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'detach' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDetachClause(Expr *Evt, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'dist_schedule' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
                             Expr *ChunkSize, SourceLocation StartLoc,
                             SourceLocation LParenLoc, SourceLocation KindLoc,
                             SourceLocation CommaLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDistScheduleClause(
      Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
}

/// Build a new OpenMP 'to' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
                   ArrayRef<SourceLocation> MotionModifiersLoc,
                   CXXScopeSpec &MapperIdScopeSpec,
                   DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
                   ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
                   ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPToClause(MotionModifiers, MotionModifiersLoc,
                                       MapperIdScopeSpec, MapperId, ColonLoc,
                                       VarList, Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'from' clause.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
OMPClause *
RebuildOMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
                     ArrayRef<SourceLocation> MotionModifiersLoc,
                     CXXScopeSpec &MapperIdScopeSpec,
                     DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
                     ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
                     ArrayRef<Expr *> UnresolvedMappers) {
  return getSema().ActOnOpenMPFromClause(
      MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
      ColonLoc, VarList, Locs, UnresolvedMappers);
}

/// Build a new OpenMP 'use_device_ptr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
                                        const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPUseDevicePtrClause(VarList, Locs);
}

/// Build a new OpenMP 'use_device_addr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
                                         const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPUseDeviceAddrClause(VarList, Locs);
}

/// Build a new OpenMP 'is_device_ptr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
                                       const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
}

/// Build a new OpenMP 'has_device_addr' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPHasDeviceAddrClause(ArrayRef<Expr *> VarList,
                                         const OMPVarListLocTy &Locs) {
  return getSema().ActOnOpenMPHasDeviceAddrClause(VarList, Locs);
}

/// Build a new OpenMP 'defaultmap' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDefaultmapClause(OpenMPDefaultmapClauseModifier M,
                                      OpenMPDefaultmapClauseKind Kind,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation MLoc,
                                      SourceLocation KindLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDefaultmapClause(M, Kind, StartLoc, LParenLoc,
                                               MLoc, KindLoc, EndLoc);
}

/// Build a new OpenMP 'nontemporal' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNontemporalClause(ArrayRef<Expr *> VarList,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNontemporalClause(VarList, StartLoc, LParenLoc,
                                                EndLoc);
}

/// Build a new OpenMP 'inclusive' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPInclusiveClause(ArrayRef<Expr *> VarList,
                                     SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPInclusiveClause(VarList, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'exclusive' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPExclusiveClause(ArrayRef<Expr *> VarList,
                                     SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPExclusiveClause(VarList, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'uses_allocators' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUsesAllocatorsClause(
    ArrayRef<Sema::UsesAllocatorsData> Data, SourceLocation StartLoc,
    SourceLocation LParenLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPUsesAllocatorClause(StartLoc, LParenLoc, EndLoc,
                                                  Data);
}

/// Build a new OpenMP 'affinity' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAffinityClause(SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation ColonLoc,
                                    SourceLocation EndLoc, Expr *Modifier,
                                    ArrayRef<Expr *> Locators) {
  return getSema().ActOnOpenMPAffinityClause(StartLoc, LParenLoc, ColonLoc,
                                             EndLoc, Modifier, Locators);
}

/// Build a new OpenMP 'order' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPOrderClause(
    OpenMPOrderClauseKind Kind, SourceLocation KindKwLoc,
    SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc,
    OpenMPOrderClauseModifier Modifier, SourceLocation ModifierKwLoc) {
  return getSema().ActOnOpenMPOrderClause(Modifier, Kind, StartLoc, LParenLoc,
                                          ModifierKwLoc, KindKwLoc, EndLoc);
}

/// Build a new OpenMP 'init' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo,
                                SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation VarLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPInitClause(InteropVar, InteropInfo, StartLoc,
                                         LParenLoc, VarLoc, EndLoc);
}

/// Build a new OpenMP 'use' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
                               SourceLocation LParenLoc,
                               SourceLocation VarLoc, SourceLocation EndLoc) {
  return getSema().ActOnOpenMPUseClause(InteropVar, StartLoc, LParenLoc,
                                        VarLoc, EndLoc);
}

/// Build a new OpenMP 'destroy' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation VarLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPDestroyClause(InteropVar, StartLoc, LParenLoc,
                                            VarLoc, EndLoc);
}

/// Build a new OpenMP 'novariants' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNovariantsClause(Expr *Condition,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNovariantsClause(Condition, StartLoc, LParenLoc,
                                               EndLoc);
}

/// Build a new OpenMP 'nocontext' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPNocontextClause(Expr *Condition, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
  return getSema().ActOnOpenMPNocontextClause(Condition, StartLoc, LParenLoc,
                                              EndLoc);
}

/// Build a new OpenMP 'filter' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc) {
  return getSema().ActOnOpenMPFilterClause(ThreadID, StartLoc, LParenLoc,
                                           EndLoc);
}

/// Build a new OpenMP 'bind' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPBindClause(OpenMPBindClauseKind Kind,
                                SourceLocation KindLoc,
                                SourceLocation StartLoc,
                                SourceLocation LParenLoc,
                                SourceLocation EndLoc) {
  return getSema().ActOnOpenMPBindClause(Kind, KindLoc, StartLoc, LParenLoc,
                                         EndLoc);
}

/// Build a new OpenMP 'ompx_dyn_cgroup_mem' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPXDynCGroupMemClause(Expr *Size, SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
                                         SourceLocation EndLoc) {
  return getSema().ActOnOpenMPXDynCGroupMemClause(Size, StartLoc, LParenLoc,
                                                  EndLoc);
}

/// Build a new OpenMP 'align' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAlignClause(Expr *A, SourceLocation StartLoc,
                                 SourceLocation LParenLoc,
                                 SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc, EndLoc);
}

/// Build a new OpenMP 'at' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPAtClause(OpenMPAtClauseKind Kind, SourceLocation KwLoc,
                              SourceLocation StartLoc,
                              SourceLocation LParenLoc,
                              SourceLocation EndLoc) {
  return getSema().ActOnOpenMPAtClause(Kind, KwLoc, StartLoc, LParenLoc,
                                       EndLoc);
}

/// Build a new OpenMP 'severity' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPSeverityClause(OpenMPSeverityClauseKind Kind,
                                    SourceLocation KwLoc,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc) {
  return getSema().ActOnOpenMPSeverityClause(Kind, KwLoc, StartLoc, LParenLoc,
                                             EndLoc);
}

/// Build a new OpenMP 'message' clause.
///
/// By default, performs semantic analysis to build the new OpenMP clause.
/// Subclasses may override this routine to provide different behavior.
OMPClause *RebuildOMPMessageClause(Expr *MS, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation EndLoc) {
  return getSema().ActOnOpenMPMessageClause(MS, StartLoc, LParenLoc, EndLoc);
}

/// Rebuild the operand to an Objective-C \@synchronized statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
                                            Expr *object) {
  return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
}

/// Build a new Objective-C \@synchronized statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
                                         Expr *Object, Stmt *Body) {
  return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
}

/// Build a new Objective-C \@autoreleasepool statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
                                          Stmt *Body) {
  return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
}

/// Build a new Objective-C fast enumeration statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
                                        Stmt *Element,
                                        Expr *Collection,
                                        SourceLocation RParenLoc,
                                        Stmt *Body) {
  StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
                                              Element,
                                              Collection,
                                              RParenLoc);
  if (ForEachStmt.isInvalid())
    return StmtError();

  return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
}

/// Build a new C++ exception declaration.
///
/// By default, performs semantic analysis to build the new decaration.
/// Subclasses may override this routine to provide different behavior.
VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
                              TypeSourceInfo *Declarator,
                              SourceLocation StartLoc,
                              SourceLocation IdLoc,
                              IdentifierInfo *Id) {
  VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
                                                     StartLoc, IdLoc, Id);
  if (Var)
    getSema().CurContext->addDecl(Var);
  return Var;
}

/// Build a new C++ catch statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
                               VarDecl *ExceptionDecl,
                               Stmt *Handler) {
  return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
                                                    Handler));
}

/// Build a new C++ try statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
                             ArrayRef<Stmt *> Handlers) {
  return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
}

/// Build a new C++0x range-based for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
                                  SourceLocation CoawaitLoc, Stmt *Init,
                                  SourceLocation ColonLoc, Stmt *Range,
                                  Stmt *Begin, Stmt *End, Expr *Cond,
                                  Expr *Inc, Stmt *LoopVar,
                                  SourceLocation RParenLoc) {
  // If we've just learned that the range is actually an Objective-C
  // collection, treat this as an Objective-C fast enumeration loop.
  if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
    if (RangeStmt->isSingleDecl()) {
      if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
        if (RangeVar->isInvalidDecl())
          return StmtError();

        Expr *RangeExpr = RangeVar->getInit();
        if (!RangeExpr->isTypeDependent() &&
            RangeExpr->getType()->isObjCObjectPointerType()) {
          // FIXME: Support init-statements in Objective-C++20 ranged for
          // statement.
          if (Init) {
            return SemaRef.Diag(Init->getBeginLoc(),
                                diag::err_objc_for_range_init_stmt)
                       << Init->getSourceRange();
          }
          return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar,
                                                      RangeExpr, RParenLoc);
        }
      }
    }
  }

  return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, Init, ColonLoc,
                                        Range, Begin, End, Cond, Inc, LoopVar,
                                        RParenLoc, Sema::BFRK_Rebuild);
}

/// Build a new C++0x range-based for statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
                                        bool IsIfExists,
                                        NestedNameSpecifierLoc QualifierLoc,
                                        DeclarationNameInfo NameInfo,
                                        Stmt *Nested) {
  return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
                                              QualifierLoc, NameInfo, Nested);
}

/// Attach body to a C++0x range-based for statement.
///
/// By default, performs semantic analysis to finish the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
  return getSema().FinishCXXForRangeStmt(ForRange, Body);
}

StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
                             Stmt *TryBlock, Stmt *Handler) {
  return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
}

StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
                                Stmt *Block) {
  return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
}

StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
  return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
}

ExprResult RebuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
                                           SourceLocation LParen,
                                           SourceLocation RParen,
                                           TypeSourceInfo *TSI) {
  return getSema().BuildSYCLUniqueStableNameExpr(OpLoc, LParen, RParen, TSI);
}

/// Build a new predefined expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildPredefinedExpr(SourceLocation Loc,
                                 PredefinedExpr::IdentKind IK) {
  return getSema().BuildPredefinedExpr(Loc, IK);
}

/// Build a new expression that references a declaration.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                      LookupResult &R,
                                      bool RequiresADL) {
  return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
}


/// Build a new expression that references a declaration.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
                              ValueDecl *VD,
                              const DeclarationNameInfo &NameInfo,
                              NamedDecl *Found,
                              TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found,
                                            TemplateArgs);
}

/// Build a new expression in parentheses.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
                                  SourceLocation RParen) {
  return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
}

/// Build a new pseudo-destructor expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
                                          SourceLocation OperatorLoc,
                                          bool isArrow,
                                          CXXScopeSpec &SS,
                                          TypeSourceInfo *ScopeType,
                                          SourceLocation CCLoc,
                                          SourceLocation TildeLoc,
                                      PseudoDestructorTypeStorage Destroyed);

/// Build a new unary operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
                                      UnaryOperatorKind Opc,
                                      Expr *SubExpr) {
  return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
}

/// Build a new builtin offsetof expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
                               TypeSourceInfo *Type,
                               ArrayRef<Sema::OffsetOfComponent> Components,
                               SourceLocation RParenLoc) {
  return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
                                        RParenLoc);
}

/// Build a new sizeof, alignof or vec_step expression with a
/// type argument.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
                                       SourceLocation OpLoc,
                                       UnaryExprOrTypeTrait ExprKind,
                                       SourceRange R) {
  return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
}

/// Build a new sizeof, alignof or vec step expression with an
/// expression argument.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
                                       UnaryExprOrTypeTrait ExprKind,
                                       SourceRange R) {
  ExprResult Result
    = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
  if (Result.isInvalid())
    return ExprError();

  return Result;
}

/// Build a new array subscript expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildArraySubscriptExpr(Expr *LHS,
                                           SourceLocation LBracketLoc,
                                           Expr *RHS,
                                           SourceLocation RBracketLoc) {
  return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
                                           LBracketLoc, RHS,
                                           RBracketLoc);
}

/// Build a new matrix subscript expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
                                      Expr *ColumnIdx,
                                      SourceLocation RBracketLoc) {
  return getSema().CreateBuiltinMatrixSubscriptExpr(Base, RowIdx, ColumnIdx,
                                                    RBracketLoc);
}

/// Build a new array section expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
                                      Expr *LowerBound,
                                      SourceLocation ColonLocFirst,
                                      SourceLocation ColonLocSecond,
                                      Expr *Length, Expr *Stride,
                                      SourceLocation RBracketLoc) {
  return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
                                            ColonLocFirst, ColonLocSecond,
                                            Length, Stride, RBracketLoc);
}

/// Build a new array shaping expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
                                      SourceLocation RParenLoc,
                                      ArrayRef<Expr *> Dims,
                                      ArrayRef<SourceRange> BracketsRanges) {
  return getSema().ActOnOMPArrayShapingExpr(Base, LParenLoc, RParenLoc, Dims,
                                            BracketsRanges);
}

/// Build a new iterator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildOMPIteratorExpr(
    SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc,
    ArrayRef<Sema::OMPIteratorData> Data) {
  return getSema().ActOnOMPIteratorExpr(/*Scope=*/nullptr, IteratorKwLoc,
                                        LLoc, RLoc, Data);
}

/// Build a new call expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
                                 MultiExprArg Args,
                                 SourceLocation RParenLoc,
                                 Expr *ExecConfig = nullptr) {
  return getSema().ActOnCallExpr(
      /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
}

ExprResult RebuildCxxSubscriptExpr(Expr *Callee, SourceLocation LParenLoc,
                                   MultiExprArg Args,
                                   SourceLocation RParenLoc) {
  return getSema().ActOnArraySubscriptExpr(
18
←
Calling 'Sema::ActOnArraySubscriptExpr'→
      /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc);
17
←
Passing value via 2nd parameter 'base'→
}

/// Build a new member access expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
                             bool isArrow,
                             NestedNameSpecifierLoc QualifierLoc,
                             SourceLocation TemplateKWLoc,
                             const DeclarationNameInfo &MemberNameInfo,
                             ValueDecl *Member,
                             NamedDecl *FoundDecl,
                      const TemplateArgumentListInfo *ExplicitTemplateArgs,
                             NamedDecl *FirstQualifierInScope) {
  ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
                                                                    isArrow);
  if (!Member->getDeclName()) {
    // We have a reference to an unnamed field.  This is always the
    // base of an anonymous struct/union member access, i.e. the
    // field is always of record type.
    assert(Member->getType()->isRecordType() &&(static_cast <bool> (Member->getType()->isRecordType
() && "unnamed member not of record type?") ? void (0
) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "clang/lib/Sema/TreeTransform.h", 2797, __extension__ __PRETTY_FUNCTION__
))
           "unnamed member not of record type?")(static_cast <bool> (Member->getType()->isRecordType
() && "unnamed member not of record type?") ? void (0
) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "clang/lib/Sema/TreeTransform.h", 2797, __extension__ __PRETTY_FUNCTION__
));

    BaseResult =
      getSema().PerformObjectMemberConversion(BaseResult.get(),
                                              QualifierLoc.getNestedNameSpecifier(),
                                              FoundDecl, Member);
    if (BaseResult.isInvalid())
      return ExprError();
    Base = BaseResult.get();

    CXXScopeSpec EmptySS;
    return getSema().BuildFieldReferenceExpr(
        Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
        DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
  }

  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  Base = BaseResult.get();
  QualType BaseType = Base->getType();

  if (isArrow && !BaseType->isPointerType())
    return ExprError();

  // FIXME: this involves duplicating earlier analysis in a lot of
  // cases; we should avoid this when possible.
  LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
  R.addDecl(FoundDecl);
  R.resolveKind();

  if (getSema().isUnevaluatedContext() && Base->isImplicitCXXThis() &&
      isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(Member)) {
    if (auto *ThisClass = cast<CXXThisExpr>(Base)
                              ->getType()
                              ->getPointeeType()
                              ->getAsCXXRecordDecl()) {
      auto *Class = cast<CXXRecordDecl>(Member->getDeclContext());
      // In unevaluated contexts, an expression supposed to be a member access
      // might reference a member in an unrelated class.
      if (!ThisClass->Equals(Class) && !ThisClass->isDerivedFrom(Class))
        return getSema().BuildDeclRefExpr(Member, Member->getType(),
                                          VK_LValue, Member->getLocation());
    }
  }

  return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
                                            SS, TemplateKWLoc,
                                            FirstQualifierInScope,
                                            R, ExplicitTemplateArgs,
                                            /*S*/nullptr);
}

/// Build a new binary operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
                                       BinaryOperatorKind Opc,
                                       Expr *LHS, Expr *RHS) {
  return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
}

/// Build a new rewritten operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXRewrittenBinaryOperator(
    SourceLocation OpLoc, BinaryOperatorKind Opcode,
    const UnresolvedSetImpl &UnqualLookups, Expr *LHS, Expr *RHS) {
  return getSema().CreateOverloadedBinOp(OpLoc, Opcode, UnqualLookups, LHS,
                                         RHS, /*RequiresADL*/false);
}

/// Build a new conditional operator expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildConditionalOperator(Expr *Cond,
                                      SourceLocation QuestionLoc,
                                      Expr *LHS,
                                      SourceLocation ColonLoc,
                                      Expr *RHS) {
  return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
                                      LHS, RHS);
}

/// Build a new C-style cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
                                       TypeSourceInfo *TInfo,
                                       SourceLocation RParenLoc,
                                       Expr *SubExpr) {
  return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
                                       SubExpr);
}

/// Build a new compound literal expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
                                            TypeSourceInfo *TInfo,
                                            SourceLocation RParenLoc,
                                            Expr *Init) {
  return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
                                            Init);
}

/// Build a new extended vector element access expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildExtVectorElementExpr(Expr *Base, SourceLocation OpLoc,
                                       bool IsArrow,
                                       SourceLocation AccessorLoc,
                                       IdentifierInfo &Accessor) {

  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
  return getSema().BuildMemberReferenceExpr(
      Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(),
      /*FirstQualifierInScope*/ nullptr, NameInfo,
      /* TemplateArgs */ nullptr,
      /*S*/ nullptr);
}

/// Build a new initializer list expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildInitList(SourceLocation LBraceLoc,
                           MultiExprArg Inits,
                           SourceLocation RBraceLoc) {
  return SemaRef.BuildInitList(LBraceLoc, Inits, RBraceLoc);
}

/// Build a new designated initializer expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDesignatedInitExpr(Designation &Desig,
                                           MultiExprArg ArrayExprs,
                                           SourceLocation EqualOrColonLoc,
                                           bool GNUSyntax,
                                           Expr *Init) {
  ExprResult Result
    = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
                                         Init);
  if (Result.isInvalid())
    return ExprError();

  return Result;
}

/// Build a new value-initialized expression.
///
/// By default, builds the implicit value initialization without performing
/// any semantic analysis. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildImplicitValueInitExpr(QualType T) {
  return new (SemaRef.Context) ImplicitValueInitExpr(T);
}

/// Build a new \c va_arg expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
                                  Expr *SubExpr, TypeSourceInfo *TInfo,
                                  SourceLocation RParenLoc) {
  return getSema().BuildVAArgExpr(BuiltinLoc,
                                  SubExpr, TInfo,
                                  RParenLoc);
}

/// Build a new expression list in parentheses.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
                                MultiExprArg SubExprs,
                                SourceLocation RParenLoc) {
  return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
}

/// Build a new address-of-label expression.
///
/// By default, performs semantic analysis, using the name of the label
/// rather than attempting to map the label statement itself.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
                                SourceLocation LabelLoc, LabelDecl *Label) {
  return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
}

/// Build a new GNU statement expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildStmtExpr(SourceLocation LParenLoc, Stmt *SubStmt,
                           SourceLocation RParenLoc, unsigned TemplateDepth) {
  return getSema().BuildStmtExpr(LParenLoc, SubStmt, RParenLoc,
                                 TemplateDepth);
}

/// Build a new __builtin_choose_expr expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
                                   Expr *Cond, Expr *LHS, Expr *RHS,
                                   SourceLocation RParenLoc) {
  return SemaRef.ActOnChooseExpr(BuiltinLoc,
                                 Cond, LHS, RHS,
                                 RParenLoc);
}

/// Build a new generic selection expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
                                       SourceLocation DefaultLoc,
                                       SourceLocation RParenLoc,
                                       Expr *ControllingExpr,
                                       ArrayRef<TypeSourceInfo *> Types,
                                       ArrayRef<Expr *> Exprs) {
  return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
                                              ControllingExpr, Types, Exprs);
}

/// Build a new overloaded operator call expression.
///
/// By default, performs semantic analysis to build the new expression.
/// The semantic analysis provides the behavior of template instantiation,
/// copying with transformations that turn what looks like an overloaded
/// operator call into a use of a builtin operator, performing
/// argument-dependent lookup, etc. Subclasses may override this routine to
/// provide different behavior.
ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
                                            SourceLocation OpLoc,
                                            Expr *Callee,
                                            Expr *First,
                                            Expr *Second);

/// Build a new C++ "named" cast expression, such as static_cast or
/// reinterpret_cast.
///
/// By default, this routine dispatches to one of the more-specific routines
/// for a particular named case, e.g., RebuildCXXStaticCastExpr().
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
                                         Stmt::StmtClass Class,
                                         SourceLocation LAngleLoc,
                                         TypeSourceInfo *TInfo,
                                         SourceLocation RAngleLoc,
                                         SourceLocation LParenLoc,
                                         Expr *SubExpr,
                                         SourceLocation RParenLoc) {
  switch (Class) {
  case Stmt::CXXStaticCastExprClass:
    return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
                                                 RAngleLoc, LParenLoc,
                                                 SubExpr, RParenLoc);

  case Stmt::CXXDynamicCastExprClass:
    return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
                                                  RAngleLoc, LParenLoc,
                                                  SubExpr, RParenLoc);

  case Stmt::CXXReinterpretCastExprClass:
    return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
                                                      RAngleLoc, LParenLoc,
                                                      SubExpr,
                                                      RParenLoc);

  case Stmt::CXXConstCastExprClass:
    return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
                                                 RAngleLoc, LParenLoc,
                                                 SubExpr, RParenLoc);

  case Stmt::CXXAddrspaceCastExprClass:
    return getDerived().RebuildCXXAddrspaceCastExpr(
        OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);

  default:
    llvm_unreachable("Invalid C++ named cast")::llvm::llvm_unreachable_internal("Invalid C++ named cast", "clang/lib/Sema/TreeTransform.h"
, 3086);
  }
}

/// Build a new C++ static_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
                                          SourceLocation LAngleLoc,
                                          TypeSourceInfo *TInfo,
                                          SourceLocation RAngleLoc,
                                          SourceLocation LParenLoc,
                                          Expr *SubExpr,
                                          SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ dynamic_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
                                           SourceLocation LAngleLoc,
                                           TypeSourceInfo *TInfo,
                                           SourceLocation RAngleLoc,
                                           SourceLocation LParenLoc,
                                           Expr *SubExpr,
                                           SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ reinterpret_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
                                               SourceLocation LAngleLoc,
                                               TypeSourceInfo *TInfo,
                                               SourceLocation RAngleLoc,
                                               SourceLocation LParenLoc,
                                               Expr *SubExpr,
                                               SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ const_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
                                         SourceLocation LAngleLoc,
                                         TypeSourceInfo *TInfo,
                                         SourceLocation RAngleLoc,
                                         SourceLocation LParenLoc,
                                         Expr *SubExpr,
                                         SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
                                     TInfo, SubExpr,
                                     SourceRange(LAngleLoc, RAngleLoc),
                                     SourceRange(LParenLoc, RParenLoc));
}

ExprResult
RebuildCXXAddrspaceCastExpr(SourceLocation OpLoc, SourceLocation LAngleLoc,
                            TypeSourceInfo *TInfo, SourceLocation RAngleLoc,
                            SourceLocation LParenLoc, Expr *SubExpr,
                            SourceLocation RParenLoc) {
  return getSema().BuildCXXNamedCast(
      OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
      SourceRange(LAngleLoc, RAngleLoc), SourceRange(LParenLoc, RParenLoc));
}

/// Build a new C++ functional-style cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
                                        SourceLocation LParenLoc,
                                        Expr *Sub,
                                        SourceLocation RParenLoc,
                                        bool ListInitialization) {
  // If Sub is a ParenListExpr, then Sub is the syntatic form of a
  // CXXParenListInitExpr. Pass its expanded arguments so that the
  // CXXParenListInitExpr can be rebuilt.
  if (auto *PLE = dyn_cast<ParenListExpr>(Sub))
    return getSema().BuildCXXTypeConstructExpr(
        TInfo, LParenLoc, MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
        RParenLoc, ListInitialization);
  return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
                                             MultiExprArg(&Sub, 1), RParenLoc,
                                             ListInitialization);
}

/// Build a new C++ __builtin_bit_cast expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc,
                                     TypeSourceInfo *TSI, Expr *Sub,
                                     SourceLocation RParenLoc) {
  return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc);
}

/// Build a new C++ typeid(type) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      TypeSourceInfo *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}


/// Build a new C++ typeid(expr) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                      SourceLocation TypeidLoc,
                                      Expr *Operand,
                                      SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
                                  RParenLoc);
}

/// Build a new C++ __uuidof(type) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
                                TypeSourceInfo *Operand,
                                SourceLocation RParenLoc) {
  return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
}

/// Build a new C++ __uuidof(expr) expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
                                Expr *Operand, SourceLocation RParenLoc) {
  return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
}

/// Build a new C++ "this" expression.
///
/// By default, builds a new "this" expression without performing any
/// semantic analysis. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
                              QualType ThisType,
                              bool isImplicit) {
  return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit);
}

/// Build a new C++ throw expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
                               bool IsThrownVariableInScope) {
  return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
}

/// Build a new C++ default-argument expression.
///
/// By default, builds a new default-argument expression, which does not
/// require any semantic analysis. Subclasses may override this routine to
/// provide different behavior.
ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param,
                                    Expr *RewrittenExpr) {
  return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
                                   RewrittenExpr, getSema().CurContext);
}

/// Build a new C++11 default-initialization expression.
///
/// By default, builds a new default field initialization expression, which
/// does not require any semantic analysis. Subclasses may override this
/// routine to provide different behavior.
ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
                                     FieldDecl *Field) {
  return getSema().BuildCXXDefaultInitExpr(Loc, Field);
}

/// Build a new C++ zero-initialization expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
                                         SourceLocation LParenLoc,
                                         SourceLocation RParenLoc) {
  return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, std::nullopt,
                                             RParenLoc,
                                             /*ListInitialization=*/false);
}

/// Build a new C++ "new" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal,
                             SourceLocation PlacementLParen,
                             MultiExprArg PlacementArgs,
                             SourceLocation PlacementRParen,
                             SourceRange TypeIdParens, QualType AllocatedType,
                             TypeSourceInfo *AllocatedTypeInfo,
                             std::optional<Expr *> ArraySize,
                             SourceRange DirectInitRange, Expr *Initializer) {
  return getSema().BuildCXXNew(StartLoc, UseGlobal,
                               PlacementLParen,
                               PlacementArgs,
                               PlacementRParen,
                               TypeIdParens,
                               AllocatedType,
                               AllocatedTypeInfo,
                               ArraySize,
                               DirectInitRange,
                               Initializer);
}

/// Build a new C++ "delete" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
                                      bool IsGlobalDelete,
                                      bool IsArrayForm,
                                      Expr *Operand) {
  return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
                                  Operand);
}

/// Build a new type trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildTypeTrait(TypeTrait Trait,
                            SourceLocation StartLoc,
                            ArrayRef<TypeSourceInfo *> Args,
                            SourceLocation RParenLoc) {
  return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
}

/// Build a new array type trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
                                 SourceLocation StartLoc,
                                 TypeSourceInfo *TSInfo,
                                 Expr *DimExpr,
                                 SourceLocation RParenLoc) {
  return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
}

/// Build a new expression trait expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
                                 SourceLocation StartLoc,
                                 Expr *Queried,
                                 SourceLocation RParenLoc) {
  return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
}

/// Build a new (previously unresolved) declaration reference
/// expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildDependentScopeDeclRefExpr(
                                        NestedNameSpecifierLoc QualifierLoc,
                                        SourceLocation TemplateKWLoc,
                                     const DeclarationNameInfo &NameInfo,
                            const TemplateArgumentListInfo *TemplateArgs,
                                        bool IsAddressOfOperand,
                                        TypeSourceInfo **RecoveryTSI) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  if (TemplateArgs || TemplateKWLoc.isValid())
    return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
                                                  TemplateArgs);

  return getSema().BuildQualifiedDeclarationNameExpr(
      SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
}

/// Build a new template-id expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
                                 SourceLocation TemplateKWLoc,
                                 LookupResult &R,
                                 bool RequiresADL,
                            const TemplateArgumentListInfo *TemplateArgs) {
  return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
                                       TemplateArgs);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXConstructExpr(QualType T,
                                   SourceLocation Loc,
                                   CXXConstructorDecl *Constructor,
                                   bool IsElidable,
                                   MultiExprArg Args,
                                   bool HadMultipleCandidates,
                                   bool ListInitialization,
                                   bool StdInitListInitialization,
                                   bool RequiresZeroInit,
                           CXXConstructExpr::ConstructionKind ConstructKind,
                                   SourceRange ParenRange) {
  // Reconstruct the constructor we originally found, which might be
  // different if this is a call to an inherited constructor.
  CXXConstructorDecl *FoundCtor = Constructor;
  if (Constructor->isInheritingConstructor())
    FoundCtor = Constructor->getInheritedConstructor().getConstructor();

  SmallVector<Expr *, 8> ConvertedArgs;
  if (getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
                                        ConvertedArgs))
    return ExprError();

  return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
                                         IsElidable,
                                         ConvertedArgs,
                                         HadMultipleCandidates,
                                         ListInitialization,
                                         StdInitListInitialization,
                                         RequiresZeroInit, ConstructKind,
                                         ParenRange);
}

/// Build a new implicit construction via inherited constructor
/// expression.
ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
                                           CXXConstructorDecl *Constructor,
                                           bool ConstructsVBase,
                                           bool InheritedFromVBase) {
  return new (getSema().Context) CXXInheritedCtorInitExpr(
      Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
                                         SourceLocation LParenOrBraceLoc,
                                         MultiExprArg Args,
                                         SourceLocation RParenOrBraceLoc,
                                         bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(
      TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
}

/// Build a new object-construction expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
                                             SourceLocation LParenLoc,
                                             MultiExprArg Args,
                                             SourceLocation RParenLoc,
                                             bool ListInitialization) {
  return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
                                             RParenLoc, ListInitialization);
}

/// Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
                                              QualType BaseType,
                                              bool IsArrow,
                                              SourceLocation OperatorLoc,
                                        NestedNameSpecifierLoc QualifierLoc,
                                              SourceLocation TemplateKWLoc,
                                          NamedDecl *FirstQualifierInScope,
                                 const DeclarationNameInfo &MemberNameInfo,
                            const TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                          OperatorLoc, IsArrow,
                                          SS, TemplateKWLoc,
                                          FirstQualifierInScope,
                                          MemberNameInfo,
                                          TemplateArgs, /*S*/nullptr);
}

/// Build a new member reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
                                       SourceLocation OperatorLoc,
                                       bool IsArrow,
                                       NestedNameSpecifierLoc QualifierLoc,
                                       SourceLocation TemplateKWLoc,
                                       NamedDecl *FirstQualifierInScope,
                                       LookupResult &R,
                              const TemplateArgumentListInfo *TemplateArgs) {
  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);

  return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                          OperatorLoc, IsArrow,
                                          SS, TemplateKWLoc,
                                          FirstQualifierInScope,
                                          R, TemplateArgs, /*S*/nullptr);
}

/// Build a new noexcept expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
  return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
}

/// Build a new expression to compute the length of a parameter pack.
ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack,
                                 SourceLocation PackLoc,
                                 SourceLocation RParenLoc,
                                 std::optional<unsigned> Length,
                                 ArrayRef<TemplateArgument> PartialArgs) {
  return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
                                RParenLoc, Length, PartialArgs);
}

/// Build a new expression representing a call to a source location
///  builtin.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                QualType ResultTy, SourceLocation BuiltinLoc,
                                SourceLocation RPLoc,
                                DeclContext *ParentContext) {
  return getSema().BuildSourceLocExpr(Kind, ResultTy, BuiltinLoc, RPLoc,
                                      ParentContext);
}

/// Build a new Objective-C boxed expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
    SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
    NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
    TemplateArgumentListInfo *TALI) {
  CXXScopeSpec SS;
  SS.Adopt(NNS);
  ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
                                                       ConceptNameInfo,
                                                       FoundDecl,
                                                       NamedConcept, TALI);
  if (Result.isInvalid())
    return ExprError();
  return Result;
}

/// \brief Build a new requires expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
                               RequiresExprBodyDecl *Body,
                               ArrayRef<ParmVarDecl *> LocalParameters,
                               ArrayRef<concepts::Requirement *> Requirements,
                               SourceLocation ClosingBraceLoc) {
  return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body,
                              LocalParameters, Requirements, ClosingBraceLoc);
}

concepts::TypeRequirement *
RebuildTypeRequirement(
    concepts::Requirement::SubstitutionDiagnostic *SubstDiag) {
  return SemaRef.BuildTypeRequirement(SubstDiag);
}

concepts::TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) {
  return SemaRef.BuildTypeRequirement(T);
}

concepts::ExprRequirement *
RebuildExprRequirement(
    concepts::Requirement::SubstitutionDiagnostic *SubstDiag, bool IsSimple,
    SourceLocation NoexceptLoc,
    concepts::ExprRequirement::ReturnTypeRequirement Ret) {
  return SemaRef.BuildExprRequirement(SubstDiag, IsSimple, NoexceptLoc,
                                      std::move(Ret));
}

concepts::ExprRequirement *
RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
                       concepts::ExprRequirement::ReturnTypeRequirement Ret) {
  return SemaRef.BuildExprRequirement(E, IsSimple, NoexceptLoc,
                                      std::move(Ret));
}

concepts::NestedRequirement *
RebuildNestedRequirement(StringRef InvalidConstraintEntity,
                         const ASTConstraintSatisfaction &Satisfaction) {
  return SemaRef.BuildNestedRequirement(InvalidConstraintEntity,
                                        Satisfaction);
}

concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) {
  return SemaRef.BuildNestedRequirement(Constraint);
}

/// \brief Build a new Objective-C boxed expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
  return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
}

/// Build a new Objective-C array literal.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCArrayLiteral(SourceRange Range,
                                   Expr **Elements, unsigned NumElements) {
  return getSema().BuildObjCArrayLiteral(Range,
                                         MultiExprArg(Elements, NumElements));
}

ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
                                       Expr *Base, Expr *Key,
                                       ObjCMethodDecl *getterMethod,
                                       ObjCMethodDecl *setterMethod) {
  return  getSema().BuildObjCSubscriptExpression(RB, Base, Key,
                                                 getterMethod, setterMethod);
}

/// Build a new Objective-C dictionary literal.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
                            MutableArrayRef<ObjCDictionaryElement> Elements) {
  return getSema().BuildObjCDictionaryLiteral(Range, Elements);
}

/// Build a new Objective-C \@encode expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
                                       TypeSourceInfo *EncodeTypeInfo,
                                       SourceLocation RParenLoc) {
  return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
}

/// Build a new Objective-C class message.
ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
                                        Selector Sel,
                                        ArrayRef<SourceLocation> SelectorLocs,
                                        ObjCMethodDecl *Method,
                                        SourceLocation LBracLoc,
                                        MultiExprArg Args,
                                        SourceLocation RBracLoc) {
  return SemaRef.BuildClassMessage(ReceiverTypeInfo,
                                   ReceiverTypeInfo->getType(),
                                   /*SuperLoc=*/SourceLocation(),
                                   Sel, Method, LBracLoc, SelectorLocs,
                                   RBracLoc, Args);
}

/// Build a new Objective-C instance message.
ExprResult RebuildObjCMessageExpr(Expr *Receiver,
                                        Selector Sel,
                                        ArrayRef<SourceLocation> SelectorLocs,
                                        ObjCMethodDecl *Method,
                                        SourceLocation LBracLoc,
                                        MultiExprArg Args,
                                        SourceLocation RBracLoc) {
  return SemaRef.BuildInstanceMessage(Receiver,
                                      Receiver->getType(),
                                      /*SuperLoc=*/SourceLocation(),
                                      Sel, Method, LBracLoc, SelectorLocs,
                                      RBracLoc, Args);
}

/// Build a new Objective-C instance/class message to 'super'.
ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
                                  Selector Sel,
                                  ArrayRef<SourceLocation> SelectorLocs,
                                  QualType SuperType,
                                  ObjCMethodDecl *Method,
                                  SourceLocation LBracLoc,
                                  MultiExprArg Args,
                                  SourceLocation RBracLoc) {
  return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr,
                                        SuperType,
                                        SuperLoc,
                                        Sel, Method, LBracLoc, SelectorLocs,
                                        RBracLoc, Args)
                                    : SemaRef.BuildClassMessage(nullptr,
                                        SuperType,
                                        SuperLoc,
                                        Sel, Method, LBracLoc, SelectorLocs,
                                        RBracLoc, Args);


}

/// Build a new Objective-C ivar reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
                                        SourceLocation IvarLoc,
                                        bool IsArrow, bool IsFreeIvar) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
  ExprResult Result = getSema().BuildMemberReferenceExpr(
      BaseArg, BaseArg->getType(),
      /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(),
      /*FirstQualifierInScope=*/nullptr, NameInfo,
      /*TemplateArgs=*/nullptr,
      /*S=*/nullptr);
  if (IsFreeIvar && Result.isUsable())
    cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
  return Result;
}

/// Build a new Objective-C property reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
                                      ObjCPropertyDecl *Property,
                                      SourceLocation PropertyLoc) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
  return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
                                            /*FIXME:*/PropertyLoc,
                                            /*IsArrow=*/false,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope=*/nullptr,
                                            NameInfo,
                                            /*TemplateArgs=*/nullptr,
                                            /*S=*/nullptr);
}

/// Build a new Objective-C property reference expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
                                      ObjCMethodDecl *Getter,
                                      ObjCMethodDecl *Setter,
                                      SourceLocation PropertyLoc) {
  // Since these expressions can only be value-dependent, we do not
  // need to perform semantic analysis again.
  return Owned(
    new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
                                                VK_LValue, OK_ObjCProperty,
                                                PropertyLoc, Base));
}

/// Build a new Objective-C "isa" expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
                              SourceLocation OpLoc, bool IsArrow) {
  CXXScopeSpec SS;
  DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
  return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
                                            OpLoc, IsArrow,
                                            SS, SourceLocation(),
                                            /*FirstQualifierInScope=*/nullptr,
                                            NameInfo,
                                            /*TemplateArgs=*/nullptr,
                                            /*S=*/nullptr);
}

/// Build a new shuffle vector expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
                                    MultiExprArg SubExprs,
                                    SourceLocation RParenLoc) {
  // Find the declaration for __builtin_shufflevector
  const IdentifierInfo &Name
    = SemaRef.Context.Idents.get("__builtin_shufflevector");
  TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
  DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
  assert(!Lookup.empty() && "No __builtin_shufflevector?")(static_cast <bool> (!Lookup.empty() && "No __builtin_shufflevector?"
) ? void (0) : __assert_fail ("!Lookup.empty() && \"No __builtin_shufflevector?\""
, "clang/lib/Sema/TreeTransform.h", 3802, __extension__ __PRETTY_FUNCTION__
));

  // Build a reference to the __builtin_shufflevector builtin
  FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
  Expr *Callee = new (SemaRef.Context)
      DeclRefExpr(SemaRef.Context, Builtin, false,
                  SemaRef.Context.BuiltinFnTy, VK_PRValue, BuiltinLoc);
  QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
  Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
                                     CK_BuiltinFnToFnPtr).get();

  // Build the CallExpr
  ExprResult TheCall = CallExpr::Create(
      SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
      Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc,
      FPOptionsOverride());

  // Type-check the __builtin_shufflevector expression.
  return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
}

/// Build a new convert vector expression.
ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
                                    Expr *SrcExpr, TypeSourceInfo *DstTInfo,
                                    SourceLocation RParenLoc) {
  return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
                                       BuiltinLoc, RParenLoc);
}

/// Build a new template argument pack expansion.
///
/// By default, performs semantic analysis to build a new pack expansion
/// for a template argument. Subclasses may override this routine to provide
/// different behavior.
TemplateArgumentLoc
RebuildPackExpansion(TemplateArgumentLoc Pattern, SourceLocation EllipsisLoc,
                     std::optional<unsigned> NumExpansions) {
  switch (Pattern.getArgument().getKind()) {
  case TemplateArgument::Expression: {
    ExprResult Result
      = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
                                     EllipsisLoc, NumExpansions);
    if (Result.isInvalid())
      return TemplateArgumentLoc();

    return TemplateArgumentLoc(Result.get(), Result.get());
  }

  case TemplateArgument::Template:
    return TemplateArgumentLoc(
        SemaRef.Context,
        TemplateArgument(Pattern.getArgument().getAsTemplate(),
                         NumExpansions),
        Pattern.getTemplateQualifierLoc(), Pattern.getTemplateNameLoc(),
        EllipsisLoc);

  case TemplateArgument::Null:
  case TemplateArgument::Integral:
  case TemplateArgument::Declaration:
  case TemplateArgument::Pack:
  case TemplateArgument::TemplateExpansion:
  case TemplateArgument::NullPtr:
    llvm_unreachable("Pack expansion pattern has no parameter packs")::llvm::llvm_unreachable_internal("Pack expansion pattern has no parameter packs"
, "clang/lib/Sema/TreeTransform.h", 3864);

  case TemplateArgument::Type:
    if (TypeSourceInfo *Expansion
          = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
                                         EllipsisLoc,
                                         NumExpansions))
      return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
                                 Expansion);
    break;
  }

  return TemplateArgumentLoc();
}

/// Build a new expression pack expansion.
///
/// By default, performs semantic analysis to build a new pack expansion
/// for an expression. Subclasses may override this routine to provide
/// different behavior.
ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
                                std::optional<unsigned> NumExpansions) {
  return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
}

/// Build a new C++1z fold-expression.
///
/// By default, performs semantic analysis in order to build a new fold
/// expression.
ExprResult RebuildCXXFoldExpr(UnresolvedLookupExpr *ULE,
                              SourceLocation LParenLoc, Expr *LHS,
                              BinaryOperatorKind Operator,
                              SourceLocation EllipsisLoc, Expr *RHS,
                              SourceLocation RParenLoc,
                              std::optional<unsigned> NumExpansions) {
  return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator,
                                    EllipsisLoc, RHS, RParenLoc,
                                    NumExpansions);
}

/// Build an empty C++1z fold-expression with the given operator.
///
/// By default, produces the fallback value for the fold-expression, or
/// produce an error if there is no fallback value.
ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
                                   BinaryOperatorKind Operator) {
  return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
}

/// Build a new atomic operation expression.
///
/// By default, performs semantic analysis to build the new expression.
/// Subclasses may override this routine to provide different behavior.
ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs,
                             AtomicExpr::AtomicOp Op,
                             SourceLocation RParenLoc) {
  // Use this for all of the locations, since we don't know the difference
  // between the call and the expr at this point.
  SourceRange Range{BuiltinLoc, RParenLoc};
  return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
                                   Sema::AtomicArgumentOrder::AST);
}

ExprResult RebuildRecoveryExpr(SourceLocation BeginLoc, SourceLocation EndLoc,
                               ArrayRef<Expr *> SubExprs, QualType Type) {
  return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs, Type);
}

3932private:
TypeLoc TransformTypeInObjectScope(TypeLoc TL,
                                   QualType ObjectType,
                                   NamedDecl *FirstQualifierInScope,
                                   CXXScopeSpec &SS);

TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                           QualType ObjectType,
                                           NamedDecl *FirstQualifierInScope,
                                           CXXScopeSpec &SS);

TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
                                          NamedDecl *FirstQualifierInScope,
                                          CXXScopeSpec &SS);

QualType TransformDependentNameType(TypeLocBuilder &TLB,
                                    DependentNameTypeLoc TL,
                                    bool DeducibleTSTContext);
3950};

3952template <typename Derived>
3953StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
if (!S)
  return S;

switch (S->getStmtClass()) {
case Stmt::NoStmtClass: break;

// Transform individual statement nodes
// Pass SDK into statements that can produce a value
3962#define STMT(Node, Parent)                                              \
case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3964#define VALUESTMT(Node, Parent)                                         \
case Stmt::Node##Class:                                               \
  return getDerived().Transform##Node(cast<Node>(S), SDK);
3967#define ABSTRACT_STMT(Node)
3968#define EXPR(Node, Parent)
3969#include "clang/AST/StmtNodes.inc"

// Transform expressions by calling TransformExpr.
3972#define STMT(Node, Parent)
3973#define ABSTRACT_STMT(Stmt)
3974#define EXPR(Node, Parent) case Stmt::Node##Class:
3975#include "clang/AST/StmtNodes.inc"
  {
    ExprResult E = getDerived().TransformExpr(cast<Expr>(S));

    if (SDK == SDK_StmtExprResult)
      E = getSema().ActOnStmtExprResult(E);
    return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
  }
}

return S;
3986}

3988template<typename Derived>
3989OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
if (!S)
  return S;

switch (S->getClauseKind()) {
default: break;
// Transform individual clause nodes
3996#define GEN_CLANG_CLAUSE_CLASS
3997#define CLAUSE_CLASS(Enum, Str, Class)                                         \
case Enum:                                                                   \
  return getDerived().Transform##Class(cast<Class>(S));
4000#include "llvm/Frontend/OpenMP/OMP.inc"
}

return S;
4004}


4007template<typename Derived>
4008ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
if (!E)
  return E;

switch (E->getStmtClass()) {
  case Stmt::NoStmtClass: break;
4014#define STMT(Node, Parent) case Stmt::Node##Class: break;
4015#define ABSTRACT_STMT(Stmt)
4016#define EXPR(Node, Parent)                                              \
  case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4018#include "clang/AST/StmtNodes.inc"
}

return E;
4022}

4024template<typename Derived>
4025ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
                                                      bool NotCopyInit) {
// Initializers are instantiated like expressions, except that various outer
// layers are stripped.
if (!Init)
  return Init;

if (auto *FE = dyn_cast<FullExpr>(Init))
  Init = FE->getSubExpr();

if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) {
  OpaqueValueExpr *OVE = AIL->getCommonExpr();
  Init = OVE->getSourceExpr();
}

if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
  Init = MTE->getSubExpr();

while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
  Init = Binder->getSubExpr();

if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
  Init = ICE->getSubExprAsWritten();

if (CXXStdInitializerListExpr *ILE =
        dyn_cast<CXXStdInitializerListExpr>(Init))
  return TransformInitializer(ILE->getSubExpr(), NotCopyInit);

// If this is copy-initialization, we only need to reconstruct
// InitListExprs. Other forms of copy-initialization will be a no-op if
// the initializer is already the right type.
CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);
if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
  return getDerived().TransformExpr(Init);

// Revert value-initialization back to empty parens.
if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) {
  SourceRange Parens = VIE->getSourceRange();
  return getDerived().RebuildParenListExpr(Parens.getBegin(), std::nullopt,
                                           Parens.getEnd());
}

// FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
if (isa<ImplicitValueInitExpr>(Init))
  return getDerived().RebuildParenListExpr(SourceLocation(), std::nullopt,
                                           SourceLocation());

// Revert initialization by constructor back to a parenthesized or braced list
// of expressions. Any other form of initializer can just be reused directly.
if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
  return getDerived().TransformExpr(Init);

// If the initialization implicitly converted an initializer list to a
// std::initializer_list object, unwrap the std::initializer_list too.
if (Construct && Construct->isStdInitListInitialization())
  return TransformInitializer(Construct->getArg(0), NotCopyInit);

// Enter a list-init context if this was list initialization.
EnterExpressionEvaluationContext Context(
    getSema(), EnterExpressionEvaluationContext::InitList,
    Construct->isListInitialization());

SmallVector<Expr*, 8> NewArgs;
bool ArgChanged = false;
if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
                                /*IsCall*/true, NewArgs, &ArgChanged))
  return ExprError();

// If this was list initialization, revert to syntactic list form.
if (Construct->isListInitialization())
  return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs,
                                      Construct->getEndLoc());

// Build a ParenListExpr to represent anything else.
SourceRange Parens = Construct->getParenOrBraceRange();
if (Parens.isInvalid()) {
  // This was a variable declaration's initialization for which no initializer
  // was specified.
  assert(NewArgs.empty() &&(static_cast <bool> (NewArgs.empty() && "no parens or braces but have direct init with arguments?"
) ? void (0) : __assert_fail ("NewArgs.empty() && \"no parens or braces but have direct init with arguments?\""
, "clang/lib/Sema/TreeTransform.h", 4104, __extension__ __PRETTY_FUNCTION__
))
         "no parens or braces but have direct init with arguments?")(static_cast <bool> (NewArgs.empty() && "no parens or braces but have direct init with arguments?"
) ? void (0) : __assert_fail ("NewArgs.empty() && \"no parens or braces but have direct init with arguments?\""
, "clang/lib/Sema/TreeTransform.h", 4104, __extension__ __PRETTY_FUNCTION__
));
  return ExprEmpty();
}
return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
                                         Parens.getEnd());
4109}

4111template<typename Derived>
4112bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
                                          unsigned NumInputs,
                                          bool IsCall,
                                    SmallVectorImpl<Expr *> &Outputs,
                                          bool *ArgChanged) {
for (unsigned I = 0; I != NumInputs; ++I) {
  // If requested, drop call arguments that need to be dropped.
  if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
    if (ArgChanged)
      *ArgChanged = true;

    break;
  }

  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
    Expr *Pattern = Expansion->getPattern();

    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 4131, __extension__ __PRETTY_FUNCTION__
));

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

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      ExprResult OutPattern = getDerived().TransformExpr(Pattern);
      if (OutPattern.isInvalid())
        return true;

      ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
                                              Expansion->getEllipsisLoc(),
                                                         NumExpansions);
      if (Out.isInvalid())
        return true;

      if (ArgChanged)
        *ArgChanged = true;
      Outputs.push_back(Out.get());
      continue;
    }

    // Record right away that the argument was changed.  This needs
    // to happen even if the array expands to nothing.
    if (ArgChanged) *ArgChanged = true;

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
      ExprResult Out = getDerived().TransformExpr(Pattern);
      if (Out.isInvalid())
        return true;

      if (Out.get()->containsUnexpandedParameterPack()) {
        Out = getDerived().RebuildPackExpansion(
            Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
        if (Out.isInvalid())
          return true;
      }

      Outputs.push_back(Out.get());
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());

      ExprResult Out = getDerived().TransformExpr(Pattern);
      if (Out.isInvalid())
        return true;

      Out = getDerived().RebuildPackExpansion(
          Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
      if (Out.isInvalid())
        return true;

      Outputs.push_back(Out.get());
    }

    continue;
  }

  ExprResult Result =
    IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
           : getDerived().TransformExpr(Inputs[I]);
  if (Result.isInvalid())
    return true;

  if (Result.get() != Inputs[I] && ArgChanged)
    *ArgChanged = true;

  Outputs.push_back(Result.get());
}

return false;
4222}

4224template <typename Derived>
4225Sema::ConditionResult TreeTransform<Derived>::TransformCondition(
  SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
if (Var) {
  VarDecl *ConditionVar = cast_or_null<VarDecl>(
      getDerived().TransformDefinition(Var->getLocation(), Var));

  if (!ConditionVar)
    return Sema::ConditionError();

  return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
}

if (Expr) {
  ExprResult CondExpr = getDerived().TransformExpr(Expr);

  if (CondExpr.isInvalid())
    return Sema::ConditionError();

  return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind,
                                  /*MissingOK=*/true);
}

return Sema::ConditionResult();
4248}

4250template <typename Derived>
4251NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
  NestedNameSpecifierLoc NNS, QualType ObjectType,
  NamedDecl *FirstQualifierInScope) {
SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;

auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) {
  for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
       Qualifier = Qualifier.getPrefix())
    Qualifiers.push_back(Qualifier);
};
insertNNS(NNS);

CXXScopeSpec SS;
while (!Qualifiers.empty()) {
  NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
  NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();

  switch (QNNS->getKind()) {
  case NestedNameSpecifier::Identifier: {
    Sema::NestedNameSpecInfo IdInfo(QNNS->getAsIdentifier(),
                                    Q.getLocalBeginLoc(), Q.getLocalEndLoc(),
                                    ObjectType);
    if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, IdInfo, false,
                                            SS, FirstQualifierInScope, false))
      return NestedNameSpecifierLoc();
    break;
  }

  case NestedNameSpecifier::Namespace: {
    NamespaceDecl *NS =
        cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
            Q.getLocalBeginLoc(), QNNS->getAsNamespace()));
    SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
    break;
  }

  case NestedNameSpecifier::NamespaceAlias: {
    NamespaceAliasDecl *Alias =
        cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
            Q.getLocalBeginLoc(), QNNS->getAsNamespaceAlias()));
    SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
              Q.getLocalEndLoc());
    break;
  }

  case NestedNameSpecifier::Global:
    // There is no meaningful transformation that one could perform on the
    // global scope.
    SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
    break;

  case NestedNameSpecifier::Super: {
    CXXRecordDecl *RD =
        cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
            SourceLocation(), QNNS->getAsRecordDecl()));
    SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc());
    break;
  }

  case NestedNameSpecifier::TypeSpecWithTemplate:
  case NestedNameSpecifier::TypeSpec: {
    TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
                                            FirstQualifierInScope, SS);

    if (!TL)
      return NestedNameSpecifierLoc();

    QualType T = TL.getType();
    if (T->isDependentType() || T->isRecordType() ||
        (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) {
      if (T->isEnumeralType())
        SemaRef.Diag(TL.getBeginLoc(),
                     diag::warn_cxx98_compat_enum_nested_name_spec);

      if (const auto ETL = TL.getAs<ElaboratedTypeLoc>()) {
        SS.Adopt(ETL.getQualifierLoc());
        TL = ETL.getNamedTypeLoc();
      }
      SS.Extend(SemaRef.Context, /*FIXME:*/ SourceLocation(), TL,
                Q.getLocalEndLoc());
      break;
    }
    // If the nested-name-specifier is an invalid type def, don't emit an
    // error because a previous error should have already been emitted.
    TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>();
    if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
      SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
          << T << SS.getRange();
    }
    return NestedNameSpecifierLoc();
  }
  }

  // The qualifier-in-scope and object type only apply to the leftmost entity.
  FirstQualifierInScope = nullptr;
  ObjectType = QualType();
}

// Don't rebuild the nested-name-specifier if we don't have to.
if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
    !getDerived().AlwaysRebuild())
  return NNS;

// If we can re-use the source-location data from the original
// nested-name-specifier, do so.
if (SS.location_size() == NNS.getDataLength() &&
    memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
  return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());

// Allocate new nested-name-specifier location information.
return SS.getWithLocInContext(SemaRef.Context);
4362}

4364template<typename Derived>
4365DeclarationNameInfo
4366TreeTransform<Derived>
:TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
DeclarationName Name = NameInfo.getName();
if (!Name)
  return DeclarationNameInfo();

switch (Name.getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXOperatorName:
case DeclarationName::CXXLiteralOperatorName:
case DeclarationName::CXXUsingDirective:
  return NameInfo;

case DeclarationName::CXXDeductionGuideName: {
  TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
  TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
      getDerived().TransformDecl(NameInfo.getLoc(), OldTemplate));
  if (!NewTemplate)
    return DeclarationNameInfo();

  DeclarationNameInfo NewNameInfo(NameInfo);
  NewNameInfo.setName(
      SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(NewTemplate));
  return NewNameInfo;
}

case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName: {
  TypeSourceInfo *NewTInfo;
  CanQualType NewCanTy;
  if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
    NewTInfo = getDerived().TransformType(OldTInfo);
    if (!NewTInfo)
      return DeclarationNameInfo();
    NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
  }
  else {
    NewTInfo = nullptr;
    TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
    QualType NewT = getDerived().TransformType(Name.getCXXNameType());
    if (NewT.isNull())
      return DeclarationNameInfo();
    NewCanTy = SemaRef.Context.getCanonicalType(NewT);
  }

  DeclarationName NewName
    = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
                                                         NewCanTy);
  DeclarationNameInfo NewNameInfo(NameInfo);
  NewNameInfo.setName(NewName);
  NewNameInfo.setNamedTypeInfo(NewTInfo);
  return NewNameInfo;
}
}

llvm_unreachable("Unknown name kind.")::llvm::llvm_unreachable_internal("Unknown name kind.", "clang/lib/Sema/TreeTransform.h"
, 4425);
4426}

4428template<typename Derived>
4429TemplateName
4430TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
                                            TemplateName Name,
                                            SourceLocation NameLoc,
                                            QualType ObjectType,
                                            NamedDecl *FirstQualifierInScope,
                                            bool AllowInjectedClassName) {
if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
  TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
  assert(Template && "qualified template name must refer to a template")(static_cast <bool> (Template && "qualified template name must refer to a template"
) ? void (0) : __assert_fail ("Template && \"qualified template name must refer to a template\""
, "clang/lib/Sema/TreeTransform.h", 4438, __extension__ __PRETTY_FUNCTION__
));

  TemplateDecl *TransTemplate
    = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
                                                            Template));
  if (!TransTemplate)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      SS.getScopeRep() == QTN->getQualifier() &&
      TransTemplate == Template)
    return Name;

  return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
                                          TransTemplate);
}

if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
  if (SS.getScopeRep()) {
    // These apply to the scope specifier, not the template.
    ObjectType = QualType();
    FirstQualifierInScope = nullptr;
  }

  if (!getDerived().AlwaysRebuild() &&
      SS.getScopeRep() == DTN->getQualifier() &&
      ObjectType.isNull())
    return Name;

  // FIXME: Preserve the location of the "template" keyword.
  SourceLocation TemplateKWLoc = NameLoc;

  if (DTN->isIdentifier()) {
    return getDerived().RebuildTemplateName(SS,
                                            TemplateKWLoc,
                                            *DTN->getIdentifier(),
                                            NameLoc,
                                            ObjectType,
                                            FirstQualifierInScope,
                                            AllowInjectedClassName);
  }

  return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
                                          DTN->getOperator(), NameLoc,
                                          ObjectType, AllowInjectedClassName);
}

if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
  TemplateDecl *TransTemplate
    = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
                                                            Template));
  if (!TransTemplate)
    return TemplateName();

  if (!getDerived().AlwaysRebuild() &&
      TransTemplate == Template)
    return Name;

  return TemplateName(TransTemplate);
}

if (SubstTemplateTemplateParmPackStorage *SubstPack
    = Name.getAsSubstTemplateTemplateParmPack()) {
  return getDerived().RebuildTemplateName(
      SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
      SubstPack->getIndex(), SubstPack->getFinal());
}

// These should be getting filtered out before they reach the AST.
llvm_unreachable("overloaded function decl survived to here")::llvm::llvm_unreachable_internal("overloaded function decl survived to here"
, "clang/lib/Sema/TreeTransform.h", 4507);
4508}

4510template<typename Derived>
4511void TreeTransform<Derived>::InventTemplateArgumentLoc(
                                       const TemplateArgument &Arg,
                                       TemplateArgumentLoc &Output) {
Output = getSema().getTrivialTemplateArgumentLoc(
    Arg, QualType(), getDerived().getBaseLocation());
4516}

4518template <typename Derived>
4519bool TreeTransform<Derived>::TransformTemplateArgument(
  const TemplateArgumentLoc &Input, TemplateArgumentLoc &Output,
  bool Uneval) {
const TemplateArgument &Arg = Input.getArgument();
switch (Arg.getKind()) {
case TemplateArgument::Null:
case TemplateArgument::Pack:
  llvm_unreachable("Unexpected TemplateArgument")::llvm::llvm_unreachable_internal("Unexpected TemplateArgument"
, "clang/lib/Sema/TreeTransform.h", 4526);

case TemplateArgument::Integral:
case TemplateArgument::NullPtr:
case TemplateArgument::Declaration: {
  // Transform a resolved template argument straight to a resolved template
  // argument. We get here when substituting into an already-substituted
  // template type argument during concept satisfaction checking.
  QualType T = Arg.getNonTypeTemplateArgumentType();
  QualType NewT = getDerived().TransformType(T);
  if (NewT.isNull())
    return true;

  ValueDecl *D = Arg.getKind() == TemplateArgument::Declaration
                     ? Arg.getAsDecl()
                     : nullptr;
  ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
                            getDerived().getBaseLocation(), D))
                      : nullptr;
  if (D && !NewD)
    return true;

  if (NewT == T && D == NewD)
    Output = Input;
  else if (Arg.getKind() == TemplateArgument::Integral)
    Output = TemplateArgumentLoc(
        TemplateArgument(getSema().Context, Arg.getAsIntegral(), NewT),
        TemplateArgumentLocInfo());
  else if (Arg.getKind() == TemplateArgument::NullPtr)
    Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
                                 TemplateArgumentLocInfo());
  else
    Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT),
                                 TemplateArgumentLocInfo());

  return false;
}

case TemplateArgument::Type: {
  TypeSourceInfo *DI = Input.getTypeSourceInfo();
  if (!DI)
    DI = InventTypeSourceInfo(Input.getArgument().getAsType());

  DI = getDerived().TransformType(DI);
  if (!DI)
    return true;

  Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
  return false;
}

case TemplateArgument::Template: {
  NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
  if (QualifierLoc) {
    QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
    if (!QualifierLoc)
      return true;
  }

  CXXScopeSpec SS;
  SS.Adopt(QualifierLoc);
  TemplateName Template = getDerived().TransformTemplateName(
      SS, Arg.getAsTemplate(), Input.getTemplateNameLoc());
  if (Template.isNull())
    return true;

  Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
                               QualifierLoc, Input.getTemplateNameLoc());
  return false;
}

case TemplateArgument::TemplateExpansion:
  llvm_unreachable("Caller should expand pack expansions")::llvm::llvm_unreachable_internal("Caller should expand pack expansions"
, "clang/lib/Sema/TreeTransform.h", 4598);

case TemplateArgument::Expression: {
  // Template argument expressions are constant expressions.
  EnterExpressionEvaluationContext Unevaluated(
      getSema(),
      Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
             : Sema::ExpressionEvaluationContext::ConstantEvaluated,
      Sema::ReuseLambdaContextDecl, /*ExprContext=*/
      Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);

  Expr *InputExpr = Input.getSourceExpression();
  if (!InputExpr)
    InputExpr = Input.getArgument().getAsExpr();

  ExprResult E = getDerived().TransformExpr(InputExpr);
  E = SemaRef.ActOnConstantExpression(E);
  if (E.isInvalid())
    return true;
  Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
  return false;
}
}

// Work around bogus GCC warning
return true;
4624}

4626/// Iterator adaptor that invents template argument location information
4627/// for each of the template arguments in its underlying iterator.
4628template<typename Derived, typename InputIterator>
4629class TemplateArgumentLocInventIterator {
TreeTransform<Derived> &Self;
InputIterator Iter;

4633public:
typedef TemplateArgumentLoc value_type;
typedef TemplateArgumentLoc reference;
typedef typename std::iterator_traits<InputIterator>::difference_type
  difference_type;
typedef std::input_iterator_tag iterator_category;

class pointer {
  TemplateArgumentLoc Arg;

public:
  explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }

  const TemplateArgumentLoc *operator->() const { return &Arg; }
};

TemplateArgumentLocInventIterator() { }

explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
                                           InputIterator Iter)
  : Self(Self), Iter(Iter) { }

TemplateArgumentLocInventIterator &operator++() {
  ++Iter;
  return *this;
}

TemplateArgumentLocInventIterator operator++(int) {
  TemplateArgumentLocInventIterator Old(*this);
  ++(*this);
  return Old;
}

reference operator*() const {
  TemplateArgumentLoc Result;
  Self.InventTemplateArgumentLoc(*Iter, Result);
  return Result;
}

pointer operator->() const { return pointer(**this); }

friend bool operator==(const TemplateArgumentLocInventIterator &X,
                       const TemplateArgumentLocInventIterator &Y) {
  return X.Iter == Y.Iter;
}

friend bool operator!=(const TemplateArgumentLocInventIterator &X,
                       const TemplateArgumentLocInventIterator &Y) {
  return X.Iter != Y.Iter;
}
4683};

4685template<typename Derived>
4686template<typename InputIterator>
4687bool TreeTransform<Derived>::TransformTemplateArguments(
  InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
  bool Uneval) {
for (; First != Last; ++First) {
  TemplateArgumentLoc Out;
  TemplateArgumentLoc In = *First;

  if (In.getArgument().getKind() == TemplateArgument::Pack) {
    // Unpack argument packs, which we translate them into separate
    // arguments.
    // FIXME: We could do much better if we could guarantee that the
    // TemplateArgumentLocInfo for the pack expansion would be usable for
    // all of the template arguments in the argument pack.
    typedef TemplateArgumentLocInventIterator<Derived,
                                              TemplateArgument::pack_iterator>
      PackLocIterator;
    if (TransformTemplateArguments(PackLocIterator(*this,
                                               In.getArgument().pack_begin()),
                                   PackLocIterator(*this,
                                                 In.getArgument().pack_end()),
                                   Outputs, Uneval))
      return true;

    continue;
  }

  if (In.getArgument().isPackExpansion()) {
    // We have a pack expansion, for which we will be substituting into
    // the pattern.
    SourceLocation Ellipsis;
    std::optional<unsigned> OrigNumExpansions;
    TemplateArgumentLoc Pattern
      = getSema().getTemplateArgumentPackExpansionPattern(
            In, Ellipsis, OrigNumExpansions);

    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 4724, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(Ellipsis,
                                             Pattern.getSourceRange(),
                                             Unexpanded,
                                             Expand,
                                             RetainExpansion,
                                             NumExpansions))
      return true;

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      TemplateArgumentLoc OutPattern;
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
        return true;

      Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
                                              NumExpansions);
      if (Out.getArgument().isNull())
        return true;

      Outputs.addArgument(Out);
      continue;
    }

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);

      if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
        return true;

      if (Out.getArgument().containsUnexpandedParameterPack()) {
        Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
                                                OrigNumExpansions);
        if (Out.getArgument().isNull())
          return true;
      }

      Outputs.addArgument(Out);
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());

      if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
        return true;

      Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
                                              OrigNumExpansions);
      if (Out.getArgument().isNull())
        return true;

      Outputs.addArgument(Out);
    }

    continue;
  }

  // The simple case:
  if (getDerived().TransformTemplateArgument(In, Out, Uneval))
    return true;

  Outputs.addArgument(Out);
}

return false;

4803}

4805//===----------------------------------------------------------------------===//
4806// Type transformation
4807//===----------------------------------------------------------------------===//

4809template<typename Derived>
4810QualType TreeTransform<Derived>::TransformType(QualType T) {
if (getDerived().AlreadyTransformed(T))
  return T;

// Temporary workaround.  All of these transformations should
// eventually turn into transformations on TypeLocs.
TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
                                              getDerived().getBaseLocation());

TypeSourceInfo *NewDI = getDerived().TransformType(DI);

if (!NewDI)
  return QualType();

return NewDI->getType();
4825}

4827template<typename Derived>
4828TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) {
// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
                     getDerived().getBaseEntity());
if (getDerived().AlreadyTransformed(DI->getType()))
  return DI;

TypeLocBuilder TLB;

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

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

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

4847template<typename Derived>
4848QualType
4849TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
switch (T.getTypeLocClass()) {
4851#define ABSTRACT_TYPELOC(CLASS, PARENT)
4852#define TYPELOC(CLASS, PARENT)                                                 \
case TypeLoc::CLASS:                                                         \
  return getDerived().Transform##CLASS##Type(TLB,                            \
                                             T.castAs<CLASS##TypeLoc>());
4856#include "clang/AST/TypeLocNodes.def"
}

llvm_unreachable("unhandled type loc!")::llvm::llvm_unreachable_internal("unhandled type loc!", "clang/lib/Sema/TreeTransform.h"
, 4859);
4860}

4862template<typename Derived>
4863QualType TreeTransform<Derived>::TransformTypeWithDeducedTST(QualType T) {
if (!isa<DependentNameType>(T))
  return TransformType(T);

if (getDerived().AlreadyTransformed(T))
  return T;
TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
                                              getDerived().getBaseLocation());
TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
return NewDI ? NewDI->getType() : QualType();
4873}

4875template<typename Derived>
4876TypeSourceInfo *
4877TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *DI) {
if (!isa<DependentNameType>(DI->getType()))
  return TransformType(DI);

// Refine the base location to the type's location.
TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
                     getDerived().getBaseEntity());
if (getDerived().AlreadyTransformed(DI->getType()))
  return DI;

TypeLocBuilder TLB;

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

auto QTL = TL.getAs<QualifiedTypeLoc>();
if (QTL)
  TL = QTL.getUnqualifiedLoc();

auto DNTL = TL.castAs<DependentNameTypeLoc>();

QualType Result = getDerived().TransformDependentNameType(
    TLB, DNTL, /*DeducedTSTContext*/true);
if (Result.isNull())
  return nullptr;

if (QTL) {
  Result = getDerived().RebuildQualifiedType(Result, QTL);
  if (Result.isNull())
    return nullptr;
  TLB.TypeWasModifiedSafely(Result);
}

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

4913template<typename Derived>
4914QualType
4915TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
                                             QualifiedTypeLoc T) {
QualType Result;
TypeLoc UnqualTL = T.getUnqualifiedLoc();
auto SuppressObjCLifetime =
    T.getType().getLocalQualifiers().hasObjCLifetime();
if (auto TTP = UnqualTL.getAs<TemplateTypeParmTypeLoc>()) {
  Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
                                                      SuppressObjCLifetime);
} else if (auto STTP = UnqualTL.getAs<SubstTemplateTypeParmPackTypeLoc>()) {
  Result = getDerived().TransformSubstTemplateTypeParmPackType(
      TLB, STTP, SuppressObjCLifetime);
} else {
  Result = getDerived().TransformType(TLB, UnqualTL);
}

if (Result.isNull())
  return QualType();

Result = getDerived().RebuildQualifiedType(Result, T);

if (Result.isNull())
  return QualType();

// RebuildQualifiedType might have updated the type, but not in a way
// that invalidates the TypeLoc. (There's no location information for
// qualifiers.)
TLB.TypeWasModifiedSafely(Result);

return Result;
4945}

4947template <typename Derived>
4948QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
                                                    QualifiedTypeLoc TL) {

SourceLocation Loc = TL.getBeginLoc();
Qualifiers Quals = TL.getType().getLocalQualifiers();

if ((T.getAddressSpace() != LangAS::Default &&
     Quals.getAddressSpace() != LangAS::Default) &&
    T.getAddressSpace() != Quals.getAddressSpace()) {
  SemaRef.Diag(Loc, diag::err_address_space_mismatch_templ_inst)
      << TL.getType() << T;
  return QualType();
}

// C++ [dcl.fct]p7:
//   [When] adding cv-qualifications on top of the function type [...] the
//   cv-qualifiers are ignored.
if (T->isFunctionType()) {
  T = SemaRef.getASTContext().getAddrSpaceQualType(T,
                                                   Quals.getAddressSpace());
  return T;
}

// C++ [dcl.ref]p1:
//   when the cv-qualifiers are introduced through the use of a typedef-name
//   or decltype-specifier [...] the cv-qualifiers are ignored.
// Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be
// applied to a reference type.
if (T->isReferenceType()) {
  // The only qualifier that applies to a reference type is restrict.
  if (!Quals.hasRestrict())
    return T;
  Quals = Qualifiers::fromCVRMask(Qualifiers::Restrict);
}

// Suppress Objective-C lifetime qualifiers if they don't make sense for the
// resulting type.
if (Quals.hasObjCLifetime()) {
  if (!T->isObjCLifetimeType() && !T->isDependentType())
    Quals.removeObjCLifetime();
  else if (T.getObjCLifetime()) {
    // Objective-C ARC:
    //   A lifetime qualifier applied to a substituted template parameter
    //   overrides the lifetime qualifier from the template argument.
    const AutoType *AutoTy;
    if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
      // 'auto' types behave the same way as template parameters.
      QualType Deduced = AutoTy->getDeducedType();
      Qualifiers Qs = Deduced.getQualifiers();
      Qs.removeObjCLifetime();
      Deduced =
          SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), Qs);
      T = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
                                      AutoTy->isDependentType(),
                                      /*isPack=*/false,
                                      AutoTy->getTypeConstraintConcept(),
                                      AutoTy->getTypeConstraintArguments());
    } else {
      // Otherwise, complain about the addition of a qualifier to an
      // already-qualified type.
      // FIXME: Why is this check not in Sema::BuildQualifiedType?
      SemaRef.Diag(Loc, diag::err_attr_objc_ownership_redundant) << T;
      Quals.removeObjCLifetime();
    }
  }
}

return SemaRef.BuildQualifiedType(T, Loc, Quals);
5016}

5018template<typename Derived>
5019TypeLoc
5020TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
                                                 QualType ObjectType,
                                                 NamedDecl *UnqualLookup,
                                                 CXXScopeSpec &SS) {
if (getDerived().AlreadyTransformed(TL.getType()))
  return TL;

TypeSourceInfo *TSI =
    TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
if (TSI)
  return TSI->getTypeLoc();
return TypeLoc();
5032}

5034template<typename Derived>
5035TypeSourceInfo *
5036TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                                 QualType ObjectType,
                                                 NamedDecl *UnqualLookup,
                                                 CXXScopeSpec &SS) {
if (getDerived().AlreadyTransformed(TSInfo->getType()))
  return TSInfo;

return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
                                 UnqualLookup, SS);
5045}

5047template <typename Derived>
5048TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
  TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
  CXXScopeSpec &SS) {
QualType T = TL.getType();
assert(!getDerived().AlreadyTransformed(T))(static_cast <bool> (!getDerived().AlreadyTransformed(T
)) ? void (0) : __assert_fail ("!getDerived().AlreadyTransformed(T)"
, "clang/lib/Sema/TreeTransform.h", 5052, __extension__ __PRETTY_FUNCTION__
));

TypeLocBuilder TLB;
QualType Result;

if (isa<TemplateSpecializationType>(T)) {
  TemplateSpecializationTypeLoc SpecTL =
      TL.castAs<TemplateSpecializationTypeLoc>();

  TemplateName Template = getDerived().TransformTemplateName(
      SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
      ObjectType, UnqualLookup, /*AllowInjectedClassName*/true);
  if (Template.isNull())
    return nullptr;

  Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
                                                            Template);
} else if (isa<DependentTemplateSpecializationType>(T)) {
  DependentTemplateSpecializationTypeLoc SpecTL =
      TL.castAs<DependentTemplateSpecializationTypeLoc>();

  TemplateName Template
    = getDerived().RebuildTemplateName(SS,
                                       SpecTL.getTemplateKeywordLoc(),
                                       *SpecTL.getTypePtr()->getIdentifier(),
                                       SpecTL.getTemplateNameLoc(),
                                       ObjectType, UnqualLookup,
                                       /*AllowInjectedClassName*/true);
  if (Template.isNull())
    return nullptr;

  Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
                                                                     SpecTL,
                                                                     Template,
                                                                     SS);
} else {
  // Nothing special needs to be done for these.
  Result = getDerived().TransformType(TLB, TL);
}

if (Result.isNull())
  return nullptr;

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

5098template <class TyLoc> static inline
5099QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
TyLoc NewT = TLB.push<TyLoc>(T.getType());
NewT.setNameLoc(T.getNameLoc());
return T.getType();
5103}

5105template<typename Derived>
5106QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
                                                    BuiltinTypeLoc T) {
BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
NewT.setBuiltinLoc(T.getBuiltinLoc());
if (T.needsExtraLocalData())
  NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
return T.getType();
5113}

5115template<typename Derived>
5116QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
                                                    ComplexTypeLoc T) {
// FIXME: recurse?
return TransformTypeSpecType(TLB, T);
5120}

5122template <typename Derived>
5123QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
                                                     AdjustedTypeLoc TL) {
// Adjustments applied during transformation are handled elsewhere.
return getDerived().TransformType(TLB, TL.getOriginalLoc());
5127}

5129template<typename Derived>
5130QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
                                                    DecayedTypeLoc TL) {
QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
if (OriginalType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    OriginalType != TL.getOriginalLoc().getType())
  Result = SemaRef.Context.getDecayedType(OriginalType);
TLB.push<DecayedTypeLoc>(Result);
// Nothing to set for DecayedTypeLoc.
return Result;
5143}

5145template<typename Derived>
5146QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
                                                    PointerTypeLoc TL) {
QualType PointeeType
  = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (PointeeType->getAs<ObjCObjectType>()) {
  // A dependent pointer type 'T *' has is being transformed such
  // that an Objective-C class type is being replaced for 'T'. The
  // resulting pointer type is an ObjCObjectPointerType, not a
  // PointerType.
  Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);

  ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
  NewT.setStarLoc(TL.getStarLoc());
  return Result;
}

if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

// Objective-C ARC can add lifetime qualifiers to the type that we're
// pointing to.
TLB.TypeWasModifiedSafely(Result->getPointeeType());

PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
NewT.setSigilLoc(TL.getSigilLoc());
return Result;
5180}

5182template<typename Derived>
5183QualType
5184TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
                                                BlockPointerTypeLoc TL) {
QualType PointeeType
  = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildBlockPointerType(PointeeType,
                                                TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
NewT.setSigilLoc(TL.getSigilLoc());
return Result;
5203}

5205/// Transforms a reference type.  Note that somewhat paradoxically we
5206/// don't care whether the type itself is an l-value type or an r-value
5207/// type;  we only care if the type was *written* as an l-value type
5208/// or an r-value type.
5209template<typename Derived>
5210QualType
5211TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
                                             ReferenceTypeLoc TL) {
const ReferenceType *T = TL.getTypePtr();

// Note that this works with the pointee-as-written.
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != T->getPointeeTypeAsWritten()) {
  Result = getDerived().RebuildReferenceType(PointeeType,
                                             T->isSpelledAsLValue(),
                                             TL.getSigilLoc());
  if (Result.isNull())
    return QualType();
}

// Objective-C ARC can add lifetime qualifiers to the type that we're
// referring to.
TLB.TypeWasModifiedSafely(
    Result->castAs<ReferenceType>()->getPointeeTypeAsWritten());

// r-value references can be rebuilt as l-value references.
ReferenceTypeLoc NewTL;
if (isa<LValueReferenceType>(Result))
  NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
else
  NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());

return Result;
5244}

5246template<typename Derived>
5247QualType
5248TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
                                               LValueReferenceTypeLoc TL) {
return TransformReferenceType(TLB, TL);
5251}

5253template<typename Derived>
5254QualType
5255TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
                                               RValueReferenceTypeLoc TL) {
return TransformReferenceType(TLB, TL);
5258}

5260template<typename Derived>
5261QualType
5262TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
                                                 MemberPointerTypeLoc TL) {
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
TypeSourceInfo *NewClsTInfo = nullptr;
if (OldClsTInfo) {
  NewClsTInfo = getDerived().TransformType(OldClsTInfo);
  if (!NewClsTInfo)
    return QualType();
}

const MemberPointerType *T = TL.getTypePtr();
QualType OldClsType = QualType(T->getClass(), 0);
QualType NewClsType;
if (NewClsTInfo)
  NewClsType = NewClsTInfo->getType();
else {
  NewClsType = getDerived().TransformType(OldClsType);
  if (NewClsType.isNull())
    return QualType();
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != T->getPointeeType() ||
    NewClsType != OldClsType) {
  Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
                                                 TL.getStarLoc());
  if (Result.isNull())
    return QualType();
}

// If we had to adjust the pointee type when building a member pointer, make
// sure to push TypeLoc info for it.
const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
if (MPT && PointeeType != MPT->getPointeeType()) {
  assert(isa<AdjustedType>(MPT->getPointeeType()))(static_cast <bool> (isa<AdjustedType>(MPT->getPointeeType
())) ? void (0) : __assert_fail ("isa<AdjustedType>(MPT->getPointeeType())"
, "clang/lib/Sema/TreeTransform.h", 5301, __extension__ __PRETTY_FUNCTION__
));
  TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
}

MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
NewTL.setSigilLoc(TL.getSigilLoc());
NewTL.setClassTInfo(NewClsTInfo);

return Result;
5310}

5312template<typename Derived>
5313QualType
5314TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
                                                 ConstantArrayTypeLoc TL) {
const ConstantArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Prefer the expression from the TypeLoc;  the other may have been uniqued.
Expr *OldSize = TL.getSizeExpr();
if (!OldSize)
  OldSize = const_cast<Expr*>(T->getSizeExpr());
Expr *NewSize = nullptr;
if (OldSize) {
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
  NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>();
  NewSize = SemaRef.ActOnConstantExpression(NewSize).get();
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    (T->getSizeExpr() && NewSize != OldSize)) {
  Result = getDerived().RebuildConstantArrayType(ElementType,
                                                 T->getSizeModifier(),
                                                 T->getSize(), NewSize,
                                           T->getIndexTypeCVRQualifiers(),
                                                 TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have either a ConstantArrayType or a VariableArrayType now:
// a ConstantArrayType is allowed to have an element type which is a
// VariableArrayType if the type is dependent.  Fortunately, all array
// types have the same location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(NewSize);

return Result;
5356}

5358template<typename Derived>
5359QualType TreeTransform<Derived>::TransformIncompleteArrayType(
                                            TypeLocBuilder &TLB,
                                            IncompleteArrayTypeLoc TL) {
const IncompleteArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildIncompleteArrayType(ElementType,
                                                   T->getSizeModifier(),
                                         T->getIndexTypeCVRQualifiers(),
                                                   TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(nullptr);

return Result;
5384}

5386template<typename Derived>
5387QualType
5388TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
                                                 VariableArrayTypeLoc TL) {
const VariableArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

ExprResult SizeResult;
{
  EnterExpressionEvaluationContext Context(
      SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
  SizeResult = getDerived().TransformExpr(T->getSizeExpr());
}
if (SizeResult.isInvalid())
  return QualType();
SizeResult =
    SemaRef.ActOnFinishFullExpr(SizeResult.get(), /*DiscardedValue*/ false);
if (SizeResult.isInvalid())
  return QualType();

Expr *Size = SizeResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    Size != T->getSizeExpr()) {
  Result = getDerived().RebuildVariableArrayType(ElementType,
                                                 T->getSizeModifier(),
                                                 Size,
                                           T->getIndexTypeCVRQualifiers(),
                                                 TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have constant size array now, but fortunately it has the same
// location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(Size);

return Result;
5431}

5433template<typename Derived>
5434QualType
5435TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
                                           DependentSizedArrayTypeLoc TL) {
const DependentSizedArrayType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Array bounds are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

// Prefer the expression from the TypeLoc;  the other may have been uniqued.
Expr *origSize = TL.getSizeExpr();
if (!origSize) origSize = T->getSizeExpr();

ExprResult sizeResult
  = getDerived().TransformExpr(origSize);
sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
if (sizeResult.isInvalid())
  return QualType();

Expr *size = sizeResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    size != origSize) {
  Result = getDerived().RebuildDependentSizedArrayType(ElementType,
                                                       T->getSizeModifier(),
                                                       size,
                                              T->getIndexTypeCVRQualifiers(),
                                                      TL.getBracketsRange());
  if (Result.isNull())
    return QualType();
}

// We might have any sort of array type now, but fortunately they
// all have the same location layout.
ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
NewTL.setLBracketLoc(TL.getLBracketLoc());
NewTL.setRBracketLoc(TL.getRBracketLoc());
NewTL.setSizeExpr(size);

return Result;
5479}

5481template <typename Derived>
5482QualType TreeTransform<Derived>::TransformDependentVectorType(
  TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
const DependentVectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
Size = SemaRef.ActOnConstantExpression(Size);
if (Size.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
    Size.get() != T->getSizeExpr()) {
  Result = getDerived().RebuildDependentVectorType(
      ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentVectorType>(Result)) {
  DependentVectorTypeLoc NewTL =
      TLB.push<DependentVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}

return Result;
5517}

5519template<typename Derived>
5520QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
                                    TypeLocBuilder &TLB,
                                    DependentSizedExtVectorTypeLoc TL) {
const DependentSizedExtVectorType *T = TL.getTypePtr();

// FIXME: ext vector locs should be nested
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

// Vector sizes are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
Size = SemaRef.ActOnConstantExpression(Size);
if (Size.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType() ||
    Size.get() != T->getSizeExpr()) {
  Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
                                                           Size.get(),
                                                       T->getAttributeLoc());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentSizedExtVectorType>(Result)) {
  DependentSizedExtVectorTypeLoc NewTL
    = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}

return Result;
5561}

5563template <typename Derived>
5564QualType
5565TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
                                                  ConstantMatrixTypeLoc TL) {
const ConstantMatrixType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) {
  Result = getDerived().RebuildConstantMatrixType(
      ElementType, T->getNumRows(), T->getNumColumns());
  if (Result.isNull())
    return QualType();
}

ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(Result);
NewTL.setAttrNameLoc(TL.getAttrNameLoc());
NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
NewTL.setAttrRowOperand(TL.getAttrRowOperand());
NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());

return Result;
5587}

5589template <typename Derived>
5590QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
  TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
const DependentSizedMatrixType *T = TL.getTypePtr();

QualType ElementType = getDerived().TransformType(T->getElementType());
if (ElementType.isNull()) {
  return QualType();
}

// Matrix dimensions are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

Expr *origRows = TL.getAttrRowOperand();
if (!origRows)
  origRows = T->getRowExpr();
Expr *origColumns = TL.getAttrColumnOperand();
if (!origColumns)
  origColumns = T->getColumnExpr();

ExprResult rowResult = getDerived().TransformExpr(origRows);
rowResult = SemaRef.ActOnConstantExpression(rowResult);
if (rowResult.isInvalid())
  return QualType();

ExprResult columnResult = getDerived().TransformExpr(origColumns);
columnResult = SemaRef.ActOnConstantExpression(columnResult);
if (columnResult.isInvalid())
  return QualType();

Expr *rows = rowResult.get();
Expr *columns = columnResult.get();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
    rows != origRows || columns != origColumns) {
  Result = getDerived().RebuildDependentSizedMatrixType(
      ElementType, rows, columns, T->getAttributeLoc());

  if (Result.isNull())
    return QualType();
}

// We might have any sort of matrix type now, but fortunately they
// all have the same location layout.
MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(Result);
NewTL.setAttrNameLoc(TL.getAttrNameLoc());
NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
NewTL.setAttrRowOperand(rows);
NewTL.setAttrColumnOperand(columns);
return Result;
5641}

5643template <typename Derived>
5644QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
  TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
const DependentAddressSpaceType *T = TL.getTypePtr();

QualType pointeeType = getDerived().TransformType(T->getPointeeType());

if (pointeeType.isNull())
  return QualType();

// Address spaces are constant expressions.
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
AddrSpace = SemaRef.ActOnConstantExpression(AddrSpace);
if (AddrSpace.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
    AddrSpace.get() != T->getAddrSpaceExpr()) {
  Result = getDerived().RebuildDependentAddressSpaceType(
      pointeeType, AddrSpace.get(), T->getAttributeLoc());
  if (Result.isNull())
    return QualType();
}

// Result might be dependent or not.
if (isa<DependentAddressSpaceType>(Result)) {
  DependentAddressSpaceTypeLoc NewTL =
      TLB.push<DependentAddressSpaceTypeLoc>(Result);

  NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
  NewTL.setAttrExprOperand(TL.getAttrExprOperand());
  NewTL.setAttrNameLoc(TL.getAttrNameLoc());

} else {
  TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
      Result, getDerived().getBaseLocation());
  TransformType(TLB, DI->getTypeLoc());
}

return Result;
5687}

5689template <typename Derived>
5690QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
                                                   VectorTypeLoc TL) {
const VectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
                                          T->getVectorKind());
  if (Result.isNull())
    return QualType();
}

VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5710}

5712template<typename Derived>
5713QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
                                                      ExtVectorTypeLoc TL) {
const VectorType *T = TL.getTypePtr();
QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
if (ElementType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ElementType != T->getElementType()) {
  Result = getDerived().RebuildExtVectorType(ElementType,
                                             T->getNumElements(),
                                             /*FIXME*/ SourceLocation());
  if (Result.isNull())
    return QualType();
}

ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
5734}

5736template <typename Derived>
5737ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
  ParmVarDecl *OldParm, int indexAdjustment,
  std::optional<unsigned> NumExpansions, bool ExpectParameterPack) {
TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
TypeSourceInfo *NewDI = nullptr;

if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
  // If we're substituting into a pack expansion type and we know the
  // length we want to expand to, just substitute for the pattern.
  TypeLoc OldTL = OldDI->getTypeLoc();
  PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();

  TypeLocBuilder TLB;
  TypeLoc NewTL = OldDI->getTypeLoc();
  TLB.reserve(NewTL.getFullDataSize());

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

  Result = RebuildPackExpansionType(Result,
                              OldExpansionTL.getPatternLoc().getSourceRange(),
                                    OldExpansionTL.getEllipsisLoc(),
                                    NumExpansions);
  if (Result.isNull())
    return nullptr;

  PackExpansionTypeLoc NewExpansionTL
    = TLB.push<PackExpansionTypeLoc>(Result);
  NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
  NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
} else
  NewDI = getDerived().TransformType(OldDI);
if (!NewDI)
  return nullptr;

if (NewDI == OldDI && indexAdjustment == 0)
  return OldParm;

ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context,
                                           OldParm->getDeclContext(),
                                           OldParm->getInnerLocStart(),
                                           OldParm->getLocation(),
                                           OldParm->getIdentifier(),
                                           NewDI->getType(),
                                           NewDI,
                                           OldParm->getStorageClass(),
                                           /* DefArg */ nullptr);
newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
                      OldParm->getFunctionScopeIndex() + indexAdjustment);
transformedLocalDecl(OldParm, {newParm});
return newParm;
5790}

5792template <typename Derived>
5793bool TreeTransform<Derived>::TransformFunctionTypeParams(
  SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
  const QualType *ParamTypes,
  const FunctionProtoType::ExtParameterInfo *ParamInfos,
  SmallVectorImpl<QualType> &OutParamTypes,
  SmallVectorImpl<ParmVarDecl *> *PVars,
  Sema::ExtParameterInfoBuilder &PInfos,
  unsigned *LastParamTransformed) {
int indexAdjustment = 0;

unsigned NumParams = Params.size();
for (unsigned i = 0; i != NumParams; ++i) {
  if (LastParamTransformed)
    *LastParamTransformed = i;
  if (ParmVarDecl *OldParm = Params[i]) {
    assert(OldParm->getFunctionScopeIndex() == i)(static_cast <bool> (OldParm->getFunctionScopeIndex(
) == i) ? void (0) : __assert_fail ("OldParm->getFunctionScopeIndex() == i"
, "clang/lib/Sema/TreeTransform.h", 5808, __extension__ __PRETTY_FUNCTION__
));

    std::optional<unsigned> NumExpansions;
    ParmVarDecl *NewParm = nullptr;
    if (OldParm->isParameterPack()) {
      // We have a function parameter pack that may need to be expanded.
      SmallVector<UnexpandedParameterPack, 2> Unexpanded;

      // Find the parameter packs that could be expanded.
      TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
      PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
      TypeLoc Pattern = ExpansionTL.getPatternLoc();
      SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);

      // Determine whether we should expand the parameter packs.
      bool ShouldExpand = false;
      bool RetainExpansion = false;
      std::optional<unsigned> OrigNumExpansions;
      if (Unexpanded.size() > 0) {
        OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
        NumExpansions = OrigNumExpansions;
        if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                                 Pattern.getSourceRange(),
                                                 Unexpanded,
                                                 ShouldExpand,
                                                 RetainExpansion,
                                                 NumExpansions)) {
          return true;
        }
      } else {
5838#ifndef NDEBUG
        const AutoType *AT =
            Pattern.getType().getTypePtr()->getContainedAutoType();
        assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) &&(static_cast <bool> ((AT && (!AT->isDeduced(
) || AT->getDeducedType().isNull())) && "Could not find parameter packs or undeduced auto type!"
) ? void (0) : __assert_fail ("(AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) && \"Could not find parameter packs or undeduced auto type!\""
, "clang/lib/Sema/TreeTransform.h", 5842, __extension__ __PRETTY_FUNCTION__
))
               "Could not find parameter packs or undeduced auto type!")(static_cast <bool> ((AT && (!AT->isDeduced(
) || AT->getDeducedType().isNull())) && "Could not find parameter packs or undeduced auto type!"
) ? void (0) : __assert_fail ("(AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) && \"Could not find parameter packs or undeduced auto type!\""
, "clang/lib/Sema/TreeTransform.h", 5842, __extension__ __PRETTY_FUNCTION__
));
5843#endif
      }

      if (ShouldExpand) {
        // Expand the function parameter pack into multiple, separate
        // parameters.
        getDerived().ExpandingFunctionParameterPack(OldParm);
        for (unsigned I = 0; I != *NumExpansions; ++I) {
          Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
          ParmVarDecl *NewParm
            = getDerived().TransformFunctionTypeParam(OldParm,
                                                      indexAdjustment++,
                                                      OrigNumExpansions,
                                              /*ExpectParameterPack=*/false);
          if (!NewParm)
            return true;

          if (ParamInfos)
            PInfos.set(OutParamTypes.size(), ParamInfos[i]);
          OutParamTypes.push_back(NewParm->getType());
          if (PVars)
            PVars->push_back(NewParm);
        }

        // If we're supposed to retain a pack expansion, do so by temporarily
        // forgetting the partially-substituted parameter pack.
        if (RetainExpansion) {
          ForgetPartiallySubstitutedPackRAII Forget(getDerived());
          ParmVarDecl *NewParm
            = getDerived().TransformFunctionTypeParam(OldParm,
                                                      indexAdjustment++,
                                                      OrigNumExpansions,
                                              /*ExpectParameterPack=*/false);
          if (!NewParm)
            return true;

          if (ParamInfos)
            PInfos.set(OutParamTypes.size(), ParamInfos[i]);
          OutParamTypes.push_back(NewParm->getType());
          if (PVars)
            PVars->push_back(NewParm);
        }

        // The next parameter should have the same adjustment as the
        // last thing we pushed, but we post-incremented indexAdjustment
        // on every push.  Also, if we push nothing, the adjustment should
        // go down by one.
        indexAdjustment--;

        // We're done with the pack expansion.
        continue;
      }

      // We'll substitute the parameter now without expanding the pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      NewParm = getDerived().TransformFunctionTypeParam(OldParm,
                                                        indexAdjustment,
                                                        NumExpansions,
                                                /*ExpectParameterPack=*/true);
      assert(NewParm->isParameterPack() &&(static_cast <bool> (NewParm->isParameterPack() &&
 "Parameter pack no longer a parameter pack after " "transformation."
) ? void (0) : __assert_fail ("NewParm->isParameterPack() && \"Parameter pack no longer a parameter pack after \" \"transformation.\""
, "clang/lib/Sema/TreeTransform.h", 5905, __extension__ __PRETTY_FUNCTION__
))
             "Parameter pack no longer a parameter pack after "(static_cast <bool> (NewParm->isParameterPack() &&
 "Parameter pack no longer a parameter pack after " "transformation."
) ? void (0) : __assert_fail ("NewParm->isParameterPack() && \"Parameter pack no longer a parameter pack after \" \"transformation.\""
, "clang/lib/Sema/TreeTransform.h", 5905, __extension__ __PRETTY_FUNCTION__
))
             "transformation.")(static_cast <bool> (NewParm->isParameterPack() &&
 "Parameter pack no longer a parameter pack after " "transformation."
) ? void (0) : __assert_fail ("NewParm->isParameterPack() && \"Parameter pack no longer a parameter pack after \" \"transformation.\""
, "clang/lib/Sema/TreeTransform.h", 5905, __extension__ __PRETTY_FUNCTION__
));
    } else {
      NewParm = getDerived().TransformFunctionTypeParam(
          OldParm, indexAdjustment, std::nullopt,
          /*ExpectParameterPack=*/false);
    }

    if (!NewParm)
      return true;

    if (ParamInfos)
      PInfos.set(OutParamTypes.size(), ParamInfos[i]);
    OutParamTypes.push_back(NewParm->getType());
    if (PVars)
      PVars->push_back(NewParm);
    continue;
  }

  // Deal with the possibility that we don't have a parameter
  // declaration for this parameter.
  assert(ParamTypes)(static_cast <bool> (ParamTypes) ? void (0) : __assert_fail
 ("ParamTypes", "clang/lib/Sema/TreeTransform.h", 5925, __extension__
 __PRETTY_FUNCTION__));
  QualType OldType = ParamTypes[i];
  bool IsPackExpansion = false;
  std::optional<unsigned> NumExpansions;
  QualType NewType;
  if (const PackExpansionType *Expansion
                                     = dyn_cast<PackExpansionType>(OldType)) {
    // We have a function parameter pack that may need to be expanded.
    QualType Pattern = Expansion->getPattern();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);

    // Determine whether we should expand the parameter packs.
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    if (getDerived().TryExpandParameterPacks(Loc, SourceRange(),
                                             Unexpanded,
                                             ShouldExpand,
                                             RetainExpansion,
                                             NumExpansions)) {
      return true;
    }

    if (ShouldExpand) {
      // Expand the function parameter pack into multiple, separate
      // parameters.
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        QualType NewType = getDerived().TransformType(Pattern);
        if (NewType.isNull())
          return true;

        if (NewType->containsUnexpandedParameterPack()) {
          NewType = getSema().getASTContext().getPackExpansionType(
              NewType, std::nullopt);

          if (NewType.isNull())
            return true;
        }

        if (ParamInfos)
          PInfos.set(OutParamTypes.size(), ParamInfos[i]);
        OutParamTypes.push_back(NewType);
        if (PVars)
          PVars->push_back(nullptr);
      }

      // We're done with the pack expansion.
      continue;
    }

    // If we're supposed to retain a pack expansion, do so by temporarily
    // forgetting the partially-substituted parameter pack.
    if (RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());
      QualType NewType = getDerived().TransformType(Pattern);
      if (NewType.isNull())
        return true;

      if (ParamInfos)
        PInfos.set(OutParamTypes.size(), ParamInfos[i]);
      OutParamTypes.push_back(NewType);
      if (PVars)
        PVars->push_back(nullptr);
    }

    // We'll substitute the parameter now without expanding the pack
    // expansion.
    OldType = Expansion->getPattern();
    IsPackExpansion = true;
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
    NewType = getDerived().TransformType(OldType);
  } else {
    NewType = getDerived().TransformType(OldType);
  }

  if (NewType.isNull())
    return true;

  if (IsPackExpansion)
    NewType = getSema().Context.getPackExpansionType(NewType,
                                                     NumExpansions);

  if (ParamInfos)
    PInfos.set(OutParamTypes.size(), ParamInfos[i]);
  OutParamTypes.push_back(NewType);
  if (PVars)
    PVars->push_back(nullptr);
}

6015#ifndef NDEBUG
if (PVars) {
  for (unsigned i = 0, e = PVars->size(); i != e; ++i)
    if (ParmVarDecl *parm = (*PVars)[i])
      assert(parm->getFunctionScopeIndex() == i)(static_cast <bool> (parm->getFunctionScopeIndex() ==
 i) ? void (0) : __assert_fail ("parm->getFunctionScopeIndex() == i"
, "clang/lib/Sema/TreeTransform.h", 6019, __extension__ __PRETTY_FUNCTION__
));
}
6021#endif

return false;
6024}

6026template<typename Derived>
6027QualType
6028TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
                                                 FunctionProtoTypeLoc TL) {
SmallVector<QualType, 4> ExceptionStorage;
TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
return getDerived().TransformFunctionProtoType(
    TLB, TL, nullptr, Qualifiers(),
    [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
      return This->getDerived().TransformExceptionSpec(
          TL.getBeginLoc(), ESI, ExceptionStorage, Changed);
    });
6038}

6040template<typename Derived> template<typename Fn>
6041QualType TreeTransform<Derived>::TransformFunctionProtoType(
  TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
  Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {

// Transform the parameters and return type.
//
// We are required to instantiate the params and return type in source order.
// When the function has a trailing return type, we instantiate the
// parameters before the return type,  since the return type can then refer
// to the parameters themselves (via decltype, sizeof, etc.).
//
SmallVector<QualType, 4> ParamTypes;
SmallVector<ParmVarDecl*, 4> ParamDecls;
Sema::ExtParameterInfoBuilder ExtParamInfos;
const FunctionProtoType *T = TL.getTypePtr();

QualType ResultType;

if (T->hasTrailingReturn()) {
  if (getDerived().TransformFunctionTypeParams(
          TL.getBeginLoc(), TL.getParams(),
          TL.getTypePtr()->param_type_begin(),
          T->getExtParameterInfosOrNull(),
          ParamTypes, &ParamDecls, ExtParamInfos))
    return QualType();

  {
    // C++11 [expr.prim.general]p3:
    //   If a declaration declares a member function or member function
    //   template of a class X, the expression this is a prvalue of type
    //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
    //   and the end of the function-definition, member-declarator, or
    //   declarator.
    Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals);

    ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
    if (ResultType.isNull())
      return QualType();
  }
}
else {
  ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
  if (ResultType.isNull())
    return QualType();

  if (getDerived().TransformFunctionTypeParams(
          TL.getBeginLoc(), TL.getParams(),
          TL.getTypePtr()->param_type_begin(),
          T->getExtParameterInfosOrNull(),
          ParamTypes, &ParamDecls, ExtParamInfos))
    return QualType();
}

FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();

bool EPIChanged = false;
if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
  return QualType();

// Handle extended parameter information.
if (auto NewExtParamInfos =
      ExtParamInfos.getPointerOrNull(ParamTypes.size())) {
  if (!EPI.ExtParameterInfos ||
      llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) !=
          llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) {
    EPIChanged = true;
  }
  EPI.ExtParameterInfos = NewExtParamInfos;
} else if (EPI.ExtParameterInfos) {
  EPIChanged = true;
  EPI.ExtParameterInfos = nullptr;
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
    T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) {
  Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
  if (Result.isNull())
    return QualType();
}

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

return Result;
6132}

6134template<typename Derived>
6135bool TreeTransform<Derived>::TransformExceptionSpec(
  SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
  SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated)(static_cast <bool> (ESI.Type != EST_Uninstantiated &&
 ESI.Type != EST_Unevaluated) ? void (0) : __assert_fail ("ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated"
, "clang/lib/Sema/TreeTransform.h", 6138, __extension__ __PRETTY_FUNCTION__
));

// Instantiate a dynamic noexcept expression, if any.
if (isComputedNoexcept(ESI.Type)) {
  EnterExpressionEvaluationContext Unevaluated(
      getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
  ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
  if (NoexceptExpr.isInvalid())
    return true;

  ExceptionSpecificationType EST = ESI.Type;
  NoexceptExpr =
      getSema().ActOnNoexceptSpec(NoexceptExpr.get(), EST);
  if (NoexceptExpr.isInvalid())
    return true;

  if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type)
    Changed = true;
  ESI.NoexceptExpr = NoexceptExpr.get();
  ESI.Type = EST;
}

if (ESI.Type != EST_Dynamic)
  return false;

// Instantiate a dynamic exception specification's type.
for (QualType T : ESI.Exceptions) {
  if (const PackExpansionType *PackExpansion =
          T->getAs<PackExpansionType>()) {
    Changed = true;

    // We have a pack expansion. Instantiate it.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
                                            Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 6173, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can and
    // should
    // be expanded.
    bool Expand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
    // FIXME: Track the location of the ellipsis (and track source location
    // information for the types in the exception specification in general).
    if (getDerived().TryExpandParameterPacks(
            Loc, SourceRange(), Unexpanded, Expand,
            RetainExpansion, NumExpansions))
      return true;

    if (!Expand) {
      // We can't expand this pack expansion into separate arguments yet;
      // just substitute into the pattern and create a new pack expansion
      // type.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      QualType U = getDerived().TransformType(PackExpansion->getPattern());
      if (U.isNull())
        return true;

      U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
      Exceptions.push_back(U);
      continue;
    }

    // Substitute into the pack expansion pattern for each slice of the
    // pack.
    for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

      QualType U = getDerived().TransformType(PackExpansion->getPattern());
      if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
        return true;

      Exceptions.push_back(U);
    }
  } else {
    QualType U = getDerived().TransformType(T);
    if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
      return true;
    if (T != U)
      Changed = true;

    Exceptions.push_back(U);
  }
}

ESI.Exceptions = Exceptions;
if (ESI.Exceptions.empty())
  ESI.Type = EST_DynamicNone;
return false;
6228}

6230template<typename Derived>
6231QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
                                               TypeLocBuilder &TLB,
                                               FunctionNoProtoTypeLoc TL) {
const FunctionNoProtoType *T = TL.getTypePtr();
QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
if (ResultType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
  Result = getDerived().RebuildFunctionNoProtoType(ResultType);

FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());

return Result;
6250}

6252template <typename Derived>
6253QualType TreeTransform<Derived>::TransformUnresolvedUsingType(
  TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {
const UnresolvedUsingType *T = TL.getTypePtr();
Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
if (!D)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
  Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(), D);
  if (Result.isNull())
    return QualType();
}

// We might get an arbitrary type spec type back.  We should at
// least always get a type spec type, though.
TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6273}

6275template <typename Derived>
6276QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,
                                                  UsingTypeLoc TL) {
const UsingType *T = TL.getTypePtr();

auto *Found = cast_or_null<UsingShadowDecl>(getDerived().TransformDecl(
    TL.getLocalSourceRange().getBegin(), T->getFoundDecl()));
if (!Found)
  return QualType();

QualType Underlying = getDerived().TransformType(T->desugar());
if (Underlying.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || Found != T->getFoundDecl() ||
    Underlying != T->getUnderlyingType()) {
  Result = getDerived().RebuildUsingType(Found, Underlying);
  if (Result.isNull())
    return QualType();
}

TLB.pushTypeSpec(Result).setNameLoc(TL.getNameLoc());
return Result;
6299}

6301template<typename Derived>
6302QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
                                                    TypedefTypeLoc TL) {
const TypedefType *T = TL.getTypePtr();
TypedefNameDecl *Typedef
  = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                             T->getDecl()));
if (!Typedef)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Typedef != T->getDecl()) {
  Result = getDerived().RebuildTypedefType(Typedef);
  if (Result.isNull())
    return QualType();
}

TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6323}

6325template<typename Derived>
6326QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
                                                    TypeOfExprTypeLoc TL) {
// typeof expressions are not potentially evaluated contexts
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
if (E.isInvalid())
  return QualType();

E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
if (E.isInvalid())
  return QualType();

QualType Result = TL.getType();
TypeOfKind Kind = Result->getAs<TypeOfExprType>()->getKind();
if (getDerived().AlwaysRebuild() || E.get() != TL.getUnderlyingExpr()) {
  Result =
      getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc(), Kind);
  if (Result.isNull())
    return QualType();
}

TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
NewTL.setTypeofLoc(TL.getTypeofLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());

return Result;
6356}

6358template<typename Derived>
6359QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
                                                   TypeOfTypeLoc TL) {
TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo();
TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
if (!New_Under_TI)
  return QualType();

QualType Result = TL.getType();
TypeOfKind Kind = Result->getAs<TypeOfType>()->getKind();
if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
  Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);
  if (Result.isNull())
    return QualType();
}

TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
NewTL.setTypeofLoc(TL.getTypeofLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
NewTL.setUnmodifiedTInfo(New_Under_TI);

return Result;
6381}

6383template<typename Derived>
6384QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
                                                     DecltypeTypeLoc TL) {
const DecltypeType *T = TL.getTypePtr();

// decltype expressions are not potentially evaluated contexts
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, nullptr,
    Sema::ExpressionEvaluationContextRecord::EK_Decltype);

ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
if (E.isInvalid())
  return QualType();

E = getSema().ActOnDecltypeExpression(E.get());
if (E.isInvalid())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    E.get() != T->getUnderlyingExpr()) {
  Result = getDerived().RebuildDecltypeType(E.get(), TL.getDecltypeLoc());
  if (Result.isNull())
    return QualType();
}
else E.get();

DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
NewTL.setDecltypeLoc(TL.getDecltypeLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
return Result;
6414}

6416template<typename Derived>
6417QualType TreeTransform<Derived>::TransformUnaryTransformType(
                                                          TypeLocBuilder &TLB,
                                                   UnaryTransformTypeLoc TL) {
QualType Result = TL.getType();
if (Result->isDependentType()) {
  const UnaryTransformType *T = TL.getTypePtr();
  QualType NewBase =
    getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
  Result = getDerived().RebuildUnaryTransformType(NewBase,
                                                  T->getUTTKind(),
                                                  TL.getKWLoc());
  if (Result.isNull())
    return QualType();
}

UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());
NewTL.setParensRange(TL.getParensRange());
NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
return Result;
6437}

6439template<typename Derived>
6440QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
  TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
const DeducedTemplateSpecializationType *T = TL.getTypePtr();

CXXScopeSpec SS;
TemplateName TemplateName = getDerived().TransformTemplateName(
    SS, T->getTemplateName(), TL.getTemplateNameLoc());
if (TemplateName.isNull())
  return QualType();

QualType OldDeduced = T->getDeducedType();
QualType NewDeduced;
if (!OldDeduced.isNull()) {
  NewDeduced = getDerived().TransformType(OldDeduced);
  if (NewDeduced.isNull())
    return QualType();
}

QualType Result = getDerived().RebuildDeducedTemplateSpecializationType(
    TemplateName, NewDeduced);
if (Result.isNull())
  return QualType();

DeducedTemplateSpecializationTypeLoc NewTL =
    TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());

return Result;
6468}

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

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Record != T->getDecl()) {
  Result = getDerived().RebuildRecordType(Record);
  if (Result.isNull())
    return QualType();
}

RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6492}

6494template<typename Derived>
6495QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
                                                 EnumTypeLoc TL) {
const EnumType *T = TL.getTypePtr();
EnumDecl *Enum
  = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
                                                      T->getDecl()));
if (!Enum)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Enum != T->getDecl()) {
  Result = getDerived().RebuildEnumType(Enum);
  if (Result.isNull())
    return QualType();
}

EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());

return Result;
6516}

6518template<typename Derived>
6519QualType TreeTransform<Derived>::TransformInjectedClassNameType(
                                       TypeLocBuilder &TLB,
                                       InjectedClassNameTypeLoc TL) {
Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
                                     TL.getTypePtr()->getDecl());
if (!D) return QualType();

QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
return T;
6529}

6531template<typename Derived>
6532QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
                                              TypeLocBuilder &TLB,
                                              TemplateTypeParmTypeLoc TL) {
return getDerived().TransformTemplateTypeParmType(
    TLB, TL,
    /*SuppressObjCLifetime=*/false);
6538}

6540template <typename Derived>
6541QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
  TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) {
return TransformTypeSpecType(TLB, TL);
6544}

6546template<typename Derived>
6547QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
                                       TypeLocBuilder &TLB,
                                       SubstTemplateTypeParmTypeLoc TL) {
const SubstTemplateTypeParmType *T = TL.getTypePtr();

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

// Substitute into the replacement type, which itself might involve something
// that needs to be transformed. This only tends to occur with default
// template arguments of template template parameters.
TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
QualType Replacement = getDerived().TransformType(T->getReplacementType());
if (Replacement.isNull())
  return QualType();

QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
    Replacement, NewReplaced, T->getIndex(), T->getPackIndex());

// Propagate type-source information.
SubstTemplateTypeParmTypeLoc NewTL
  = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;

6572}

6574template<typename Derived>
6575QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
                                        TypeLocBuilder &TLB,
                                        SubstTemplateTypeParmPackTypeLoc TL) {
return getDerived().TransformSubstTemplateTypeParmPackType(
    TLB, TL, /*SuppressObjCLifetime=*/false);
6580}

6582template <typename Derived>
6583QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
  TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) {
return TransformTypeSpecType(TLB, TL);
6586}

6588template<typename Derived>
6589QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                      TypeLocBuilder &TLB,
                                         TemplateSpecializationTypeLoc TL) {
const TemplateSpecializationType *T = TL.getTypePtr();

// The nested-name-specifier never matters in a TemplateSpecializationType,
// because we can't have a dependent nested-name-specifier anyway.
CXXScopeSpec SS;
TemplateName Template
  = getDerived().TransformTemplateName(SS, T->getTemplateName(),
                                       TL.getTemplateNameLoc());
if (Template.isNull())
  return QualType();

return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
6604}

6606template<typename Derived>
6607QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
                                                   AtomicTypeLoc TL) {
QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
if (ValueType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    ValueType != TL.getValueLoc().getType()) {
  Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
  if (Result.isNull())
    return QualType();
}

AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());

return Result;
6627}

6629template <typename Derived>
6630QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
                                                 PipeTypeLoc TL) {
QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
if (ValueType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
  const PipeType *PT = Result->castAs<PipeType>();
  bool isReadPipe = PT->isReadOnly();
  Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
  if (Result.isNull())
    return QualType();
}

PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
NewTL.setKWLoc(TL.getKWLoc());

return Result;
6649}

6651template <typename Derived>
6652QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,
                                                   BitIntTypeLoc TL) {
const BitIntType *EIT = TL.getTypePtr();
QualType Result = TL.getType();

if (getDerived().AlwaysRebuild()) {
  Result = getDerived().RebuildBitIntType(EIT->isUnsigned(),
                                          EIT->getNumBits(), TL.getNameLoc());
  if (Result.isNull())
    return QualType();
}

BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
return Result;
6667}

6669template <typename Derived>
6670QualType TreeTransform<Derived>::TransformDependentBitIntType(
  TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {
const DependentBitIntType *EIT = TL.getTypePtr();

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
BitsExpr = SemaRef.ActOnConstantExpression(BitsExpr);

if (BitsExpr.isInvalid())
  return QualType();

QualType Result = TL.getType();

if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
  Result = getDerived().RebuildDependentBitIntType(
      EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());

  if (Result.isNull())
    return QualType();
}

if (isa<DependentBitIntType>(Result)) {
  DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
} else {
  BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result);
  NewTL.setNameLoc(TL.getNameLoc());
}
return Result;
6700}

/// Simple iterator that traverses the template arguments in a
/// container that provides a \c getArgLoc() member function.
///
/// This iterator is intended to be used with the iterator form of
/// \c TreeTransform<Derived>::TransformTemplateArguments().
template<typename ArgLocContainer>
class TemplateArgumentLocContainerIterator {
  ArgLocContainer *Container;
  unsigned Index;

public:
  typedef TemplateArgumentLoc value_type;
  typedef TemplateArgumentLoc reference;
  typedef int difference_type;
  typedef std::input_iterator_tag iterator_category;

  class pointer {
    TemplateArgumentLoc Arg;

  public:
    explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }

    const TemplateArgumentLoc *operator->() const {
      return &Arg;
    }
  };


  TemplateArgumentLocContainerIterator() {}

  TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
                               unsigned Index)
    : Container(&Container), Index(Index) { }

  TemplateArgumentLocContainerIterator &operator++() {
    ++Index;
    return *this;
  }

  TemplateArgumentLocContainerIterator operator++(int) {
    TemplateArgumentLocContainerIterator Old(*this);
    ++(*this);
    return Old;
  }

  TemplateArgumentLoc operator*() const {
    return Container->getArgLoc(Index);
  }

  pointer operator->() const {
    return pointer(Container->getArgLoc(Index));
  }

  friend bool operator==(const TemplateArgumentLocContainerIterator &X,
                         const TemplateArgumentLocContainerIterator &Y) {
    return X.Container == Y.Container && X.Index == Y.Index;
  }

  friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
                         const TemplateArgumentLocContainerIterator &Y) {
    return !(X == Y);
  }
};

6766template<typename Derived>
6767QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
                                                 AutoTypeLoc TL) {
const AutoType *T = TL.getTypePtr();
QualType OldDeduced = T->getDeducedType();
QualType NewDeduced;
if (!OldDeduced.isNull()) {
  NewDeduced = getDerived().TransformType(OldDeduced);
  if (NewDeduced.isNull())
    return QualType();
}

ConceptDecl *NewCD = nullptr;
TemplateArgumentListInfo NewTemplateArgs;
NestedNameSpecifierLoc NewNestedNameSpec;
if (T->isConstrained()) {
  NewCD = cast_or_null<ConceptDecl>(getDerived().TransformDecl(
      TL.getConceptNameLoc(), T->getTypeConstraintConcept()));

  NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
  NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
  typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
  if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                              ArgIterator(TL,
                                                          TL.getNumArgs()),
                                              NewTemplateArgs))
    return QualType();

  if (TL.getNestedNameSpecifierLoc()) {
    NewNestedNameSpec
      = getDerived().TransformNestedNameSpecifierLoc(
          TL.getNestedNameSpecifierLoc());
    if (!NewNestedNameSpec)
      return QualType();
  }
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
    T->isDependentType() || T->isConstrained()) {
  // FIXME: Maybe don't rebuild if all template arguments are the same.
  llvm::SmallVector<TemplateArgument, 4> NewArgList;
  NewArgList.reserve(NewTemplateArgs.size());
  for (const auto &ArgLoc : NewTemplateArgs.arguments())
    NewArgList.push_back(ArgLoc.getArgument());
  Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
                                        NewArgList);
  if (Result.isNull())
    return QualType();
}

AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
NewTL.setNameLoc(TL.getNameLoc());
NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec);
NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
NewTL.setConceptNameLoc(TL.getConceptNameLoc());
NewTL.setFoundDecl(TL.getFoundDecl());
NewTL.setLAngleLoc(TL.getLAngleLoc());
NewTL.setRAngleLoc(TL.getRAngleLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
for (unsigned I = 0; I < NewTL.getNumArgs(); ++I)
  NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo());

return Result;
6830}

6832template <typename Derived>
6833QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                      TypeLocBuilder &TLB,
                                         TemplateSpecializationTypeLoc TL,
                                                    TemplateName Template) {
TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
  ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

// FIXME: maybe don't rebuild if all the template arguments are the same.

QualType Result =
  getDerived().RebuildTemplateSpecializationType(Template,
                                                 TL.getTemplateNameLoc(),
                                                 NewTemplateArgs);

if (!Result.isNull()) {
  // Specializations of template template parameters are represented as
  // TemplateSpecializationTypes, and substitution of type alias templates
  // within a dependent context can transform them into
  // DependentTemplateSpecializationTypes.
  if (isa<DependentTemplateSpecializationType>(Result)) {
    DependentTemplateSpecializationTypeLoc NewTL
      = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
    NewTL.setElaboratedKeywordLoc(SourceLocation());
    NewTL.setQualifierLoc(NestedNameSpecifierLoc());
    NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
    NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
    NewTL.setLAngleLoc(TL.getLAngleLoc());
    NewTL.setRAngleLoc(TL.getRAngleLoc());
    for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
      NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
    return Result;
  }

  TemplateSpecializationTypeLoc NewTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
}

return Result;
6884}

6886template <typename Derived>
6887QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
                                   TypeLocBuilder &TLB,
                                   DependentTemplateSpecializationTypeLoc TL,
                                   TemplateName Template,
                                   CXXScopeSpec &SS) {
TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
typedef TemplateArgumentLocContainerIterator<
          DependentTemplateSpecializationTypeLoc> ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

// FIXME: maybe don't rebuild if all the template arguments are the same.

if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
  QualType Result = getSema().Context.getDependentTemplateSpecializationType(
      TL.getTypePtr()->getKeyword(), DTN->getQualifier(),
      DTN->getIdentifier(), NewTemplateArgs.arguments());

  DependentTemplateSpecializationTypeLoc NewTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
  return Result;
}

QualType Result
  = getDerived().RebuildTemplateSpecializationType(Template,
                                                   TL.getTemplateNameLoc(),
                                                   NewTemplateArgs);

if (!Result.isNull()) {
  /// FIXME: Wrap this in an elaborated-type-specifier?
  TemplateSpecializationTypeLoc NewTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NewTL.setLAngleLoc(TL.getLAngleLoc());
  NewTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
    NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
}

return Result;
6940}

6942template<typename Derived>
6943QualType
6944TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
                                              ElaboratedTypeLoc TL) {
const ElaboratedType *T = TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc;
// NOTE: the qualifier in an ElaboratedType is optional.
if (TL.getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
  if (!QualifierLoc)
    return QualType();
}

QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
if (NamedT.isNull())
  return QualType();

// C++0x [dcl.type.elab]p2:
//   If the identifier resolves to a typedef-name or the simple-template-id
//   resolves to an alias template specialization, the
//   elaborated-type-specifier is ill-formed.
if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) {
  if (const TemplateSpecializationType *TST =
        NamedT->getAs<TemplateSpecializationType>()) {
    TemplateName Template = TST->getTemplateName();
    if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
            Template.getAsTemplateDecl())) {
      SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(),
                   diag::err_tag_reference_non_tag)
          << TAT << Sema::NTK_TypeAliasTemplate
          << ElaboratedType::getTagTypeKindForKeyword(T->getKeyword());
      SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
    }
  }
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    QualifierLoc != TL.getQualifierLoc() ||
    NamedT != T->getNamedType()) {
  Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(),
                                              T->getKeyword(),
                                              QualifierLoc, NamedT);
  if (Result.isNull())
    return QualType();
}

ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
NewTL.setQualifierLoc(QualifierLoc);
return Result;
6995}

6997template<typename Derived>
6998QualType TreeTransform<Derived>::TransformAttributedType(
                                              TypeLocBuilder &TLB,
                                              AttributedTypeLoc TL) {
const AttributedType *oldType = TL.getTypePtr();
QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
if (modifiedType.isNull())
  return QualType();

// oldAttr can be null if we started with a QualType rather than a TypeLoc.
const Attr *oldAttr = TL.getAttr();
const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) : nullptr;
if (oldAttr && !newAttr)
  return QualType();

QualType result = TL.getType();

// FIXME: dependent operand expressions?
if (getDerived().AlwaysRebuild() ||
    modifiedType != oldType->getModifiedType()) {
  // TODO: this is really lame; we should really be rebuilding the
  // equivalent type from first principles.
  QualType equivalentType
    = getDerived().TransformType(oldType->getEquivalentType());
  if (equivalentType.isNull())
    return QualType();

  // Check whether we can add nullability; it is only represented as
  // type sugar, and therefore cannot be diagnosed in any other way.
  if (auto nullability = oldType->getImmediateNullability()) {
    if (!modifiedType->canHaveNullability()) {
      SemaRef.Diag((TL.getAttr() ? TL.getAttr()->getLocation()
                                 : TL.getModifiedLoc().getBeginLoc()),
                   diag::err_nullability_nonpointer)
          << DiagNullabilityKind(*nullability, false) << modifiedType;
      return QualType();
    }
  }

  result = SemaRef.Context.getAttributedType(TL.getAttrKind(),
                                             modifiedType,
                                             equivalentType);
}

AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
newTL.setAttr(newAttr);
return result;
7044}

7046template <typename Derived>
7047QualType TreeTransform<Derived>::TransformBTFTagAttributedType(
  TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {
// The BTFTagAttributedType is available for C only.
llvm_unreachable("Unexpected TreeTransform for BTFTagAttributedType")::llvm::llvm_unreachable_internal("Unexpected TreeTransform for BTFTagAttributedType"
, "clang/lib/Sema/TreeTransform.h", 7050);
7051}

7053template<typename Derived>
7054QualType
7055TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
                                         ParenTypeLoc TL) {
QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
if (Inner.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Inner != TL.getInnerLoc().getType()) {
  Result = getDerived().RebuildParenType(Inner);
  if (Result.isNull())
    return QualType();
}

ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
NewTL.setLParenLoc(TL.getLParenLoc());
NewTL.setRParenLoc(TL.getRParenLoc());
return Result;
7073}

7075template <typename Derived>
7076QualType
7077TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
                                                  MacroQualifiedTypeLoc TL) {
QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
if (Inner.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
  Result =
      getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
  if (Result.isNull())
    return QualType();
}

MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result);
NewTL.setExpansionLoc(TL.getExpansionLoc());
return Result;
7094}

7096template<typename Derived>
7097QualType TreeTransform<Derived>::TransformDependentNameType(
  TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
return TransformDependentNameType(TLB, TL, false);
7100}

7102template<typename Derived>
7103QualType TreeTransform<Derived>::TransformDependentNameType(
  TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext) {
const DependentNameType *T = TL.getTypePtr();

NestedNameSpecifierLoc QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
if (!QualifierLoc)
  return QualType();

QualType Result
  = getDerived().RebuildDependentNameType(T->getKeyword(),
                                          TL.getElaboratedKeywordLoc(),
                                          QualifierLoc,
                                          T->getIdentifier(),
                                          TL.getNameLoc(),
                                          DeducedTSTContext);
if (Result.isNull())
  return QualType();

if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
  QualType NamedT = ElabT->getNamedType();
  TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());

  ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
} else {
  DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
  NewTL.setNameLoc(TL.getNameLoc());
}
return Result;
7136}

7138template<typename Derived>
7139QualType TreeTransform<Derived>::
        TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                               DependentTemplateSpecializationTypeLoc TL) {
NestedNameSpecifierLoc QualifierLoc;
if (TL.getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
  if (!QualifierLoc)
    return QualType();
}

return getDerived()
         .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
7152}

7154template<typename Derived>
7155QualType TreeTransform<Derived>::
7156TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
                                 DependentTemplateSpecializationTypeLoc TL,
                                     NestedNameSpecifierLoc QualifierLoc) {
const DependentTemplateSpecializationType *T = TL.getTypePtr();

TemplateArgumentListInfo NewTemplateArgs;
NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());

typedef TemplateArgumentLocContainerIterator<
DependentTemplateSpecializationTypeLoc> ArgIterator;
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                            ArgIterator(TL, TL.getNumArgs()),
                                            NewTemplateArgs))
  return QualType();

QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
    T->getKeyword(), QualifierLoc, TL.getTemplateKeywordLoc(),
    T->getIdentifier(), TL.getTemplateNameLoc(), NewTemplateArgs,
    /*AllowInjectedClassName*/ false);
if (Result.isNull())
  return QualType();

if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
  QualType NamedT = ElabT->getNamedType();

  // Copy information relevant to the template specialization.
  TemplateSpecializationTypeLoc NamedTL
    = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
  NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  NamedTL.setLAngleLoc(TL.getLAngleLoc());
  NamedTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());

  // Copy information relevant to the elaborated type.
  ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
  NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  NewTL.setQualifierLoc(QualifierLoc);
} else if (isa<DependentTemplateSpecializationType>(Result)) {
  DependentTemplateSpecializationTypeLoc SpecTL
    = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
  SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
  SpecTL.setQualifierLoc(QualifierLoc);
  SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  SpecTL.setLAngleLoc(TL.getLAngleLoc());
  SpecTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
} else {
  TemplateSpecializationTypeLoc SpecTL
    = TLB.push<TemplateSpecializationTypeLoc>(Result);
  SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
  SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
  SpecTL.setLAngleLoc(TL.getLAngleLoc());
  SpecTL.setRAngleLoc(TL.getRAngleLoc());
  for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
    SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
}
return Result;
7218}

7220template<typename Derived>
7221QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
                                                    PackExpansionTypeLoc TL) {
QualType Pattern
  = getDerived().TransformType(TLB, TL.getPatternLoc());
if (Pattern.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    Pattern != TL.getPatternLoc().getType()) {
  Result = getDerived().RebuildPackExpansionType(Pattern,
                                         TL.getPatternLoc().getSourceRange(),
                                                 TL.getEllipsisLoc(),
                                         TL.getTypePtr()->getNumExpansions());
  if (Result.isNull())
    return QualType();
}

PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
NewT.setEllipsisLoc(TL.getEllipsisLoc());
return Result;
7242}

7244template<typename Derived>
7245QualType
7246TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
                                                 ObjCInterfaceTypeLoc TL) {
// ObjCInterfaceType is never dependent.
TLB.pushFullCopy(TL);
return TL.getType();
7251}

7253template<typename Derived>
7254QualType
7255TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
                                                 ObjCTypeParamTypeLoc TL) {
const ObjCTypeParamType *T = TL.getTypePtr();
ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
    getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
if (!OTP)
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    OTP != T->getDecl()) {
  Result = getDerived().RebuildObjCTypeParamType(
      OTP, TL.getProtocolLAngleLoc(),
      llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
      TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
  if (Result.isNull())
    return QualType();
}

ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
if (TL.getNumProtocols()) {
  NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
  for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
    NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
  NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
}
return Result;
7282}

7284template<typename Derived>
7285QualType
7286TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
                                              ObjCObjectTypeLoc TL) {
// Transform base type.
QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
if (BaseType.isNull())
  return QualType();

bool AnyChanged = BaseType != TL.getBaseLoc().getType();

// Transform type arguments.
SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
  TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
  TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
  QualType TypeArg = TypeArgInfo->getType();
  if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
    AnyChanged = true;

    // We have a pack expansion. Instantiate it.
    const auto *PackExpansion = PackExpansionLoc.getType()
                                  ->castAs<PackExpansionType>();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
                                            Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 7310, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can
    // and should be expanded.
    TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
    bool Expand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
    if (getDerived().TryExpandParameterPacks(
          PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
          Unexpanded, Expand, RetainExpansion, NumExpansions))
      return QualType();

    if (!Expand) {
      // We can't expand this pack expansion into separate arguments yet;
      // just substitute into the pattern and create a new pack expansion
      // type.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

      TypeLocBuilder TypeArgBuilder;
      TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
      QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
                                                           PatternLoc);
      if (NewPatternType.isNull())
        return QualType();

      QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
                                    NewPatternType, NumExpansions);
      auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
      NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
      NewTypeArgInfos.push_back(
        TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
      continue;
    }

    // Substitute into the pack expansion pattern for each slice of the
    // pack.
    for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);

      TypeLocBuilder TypeArgBuilder;
      TypeArgBuilder.reserve(PatternLoc.getFullDataSize());

      QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
                                                       PatternLoc);
      if (NewTypeArg.isNull())
        return QualType();

      NewTypeArgInfos.push_back(
        TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
    }

    continue;
  }

  TypeLocBuilder TypeArgBuilder;
  TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
  QualType NewTypeArg =
      getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
  if (NewTypeArg.isNull())
    return QualType();

  // If nothing changed, just keep the old TypeSourceInfo.
  if (NewTypeArg == TypeArg) {
    NewTypeArgInfos.push_back(TypeArgInfo);
    continue;
  }

  NewTypeArgInfos.push_back(
    TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
  AnyChanged = true;
}

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() || AnyChanged) {
  // Rebuild the type.
  Result = getDerived().RebuildObjCObjectType(
      BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
      TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
      llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
      TL.getProtocolLocs(), TL.getProtocolRAngleLoc());

  if (Result.isNull())
    return QualType();
}

ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
NewT.setHasBaseTypeAsWritten(true);
NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
  NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
  NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
return Result;
7407}

7409template<typename Derived>
7410QualType
7411TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
                                             ObjCObjectPointerTypeLoc TL) {
QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
if (PointeeType.isNull())
  return QualType();

QualType Result = TL.getType();
if (getDerived().AlwaysRebuild() ||
    PointeeType != TL.getPointeeLoc().getType()) {
  Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
                                                     TL.getStarLoc());
  if (Result.isNull())
    return QualType();
}

ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
NewT.setStarLoc(TL.getStarLoc());
return Result;
7429}

7431//===----------------------------------------------------------------------===//
7432// Statement transformation
7433//===----------------------------------------------------------------------===//
7434template<typename Derived>
7435StmtResult
7436TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
return S;
7438}

7440template<typename Derived>
7441StmtResult
7442TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
return getDerived().TransformCompoundStmt(S, false);
7444}

7446template<typename Derived>
7447StmtResult
7448TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
                                            bool IsStmtExpr) {
Sema::CompoundScopeRAII CompoundScope(getSema());

const Stmt *ExprResult = S->getStmtExprResult();
bool SubStmtInvalid = false;
bool SubStmtChanged = false;
SmallVector<Stmt*, 8> Statements;
for (auto *B : S->body()) {
  StmtResult Result = getDerived().TransformStmt(
      B, IsStmtExpr && B == ExprResult ? SDK_StmtExprResult : SDK_Discarded);

  if (Result.isInvalid()) {
    // Immediately fail if this was a DeclStmt, since it's very
    // likely that this will cause problems for future statements.
    if (isa<DeclStmt>(B))
      return StmtError();

    // Otherwise, just keep processing substatements and fail later.
    SubStmtInvalid = true;
    continue;
  }

  SubStmtChanged = SubStmtChanged || Result.get() != B;
  Statements.push_back(Result.getAs<Stmt>());
}

if (SubStmtInvalid)
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    !SubStmtChanged)
  return S;

return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
                                        Statements,
                                        S->getRBracLoc(),
                                        IsStmtExpr);
7486}

7488template<typename Derived>
7489StmtResult
7490TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
ExprResult LHS, RHS;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);

  // Transform the left-hand case value.
  LHS = getDerived().TransformExpr(S->getLHS());
  LHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), LHS);
  if (LHS.isInvalid())
    return StmtError();

  // Transform the right-hand case value (for the GNU case-range extension).
  RHS = getDerived().TransformExpr(S->getRHS());
  RHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), RHS);
  if (RHS.isInvalid())
    return StmtError();
}

// Build the case statement.
// Case statements are always rebuilt so that they will attached to their
// transformed switch statement.
StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
                                                     LHS.get(),
                                                     S->getEllipsisLoc(),
                                                     RHS.get(),
                                                     S->getColonLoc());
if (Case.isInvalid())
  return StmtError();

// Transform the statement following the case
StmtResult SubStmt =
    getDerived().TransformStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// Attach the body to the case statement
return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
7528}

7530template <typename Derived>
7531StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
// Transform the statement following the default case
StmtResult SubStmt =
    getDerived().TransformStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// Default statements are always rebuilt
return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
                                       SubStmt.get());
7541}

7543template<typename Derived>
7544StmtResult
7545TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
if (SubStmt.isInvalid())
  return StmtError();

Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
                                      S->getDecl());
if (!LD)
  return StmtError();

// If we're transforming "in-place" (we're not creating new local
// declarations), assume we're replacing the old label statement
// and clear out the reference to it.
if (LD == S->getDecl())
  S->getDecl()->setStmt(nullptr);

// FIXME: Pass the real colon location in.
return getDerived().RebuildLabelStmt(S->getIdentLoc(),
                                     cast<LabelDecl>(LD), SourceLocation(),
                                     SubStmt.get());
7565}

7567template <typename Derived>
7568const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
if (!R)
  return R;

switch (R->getKind()) {
7573// Transform attributes by calling TransformXXXAttr.
7574#define ATTR(X)                                                                \
case attr::X:                                                                \
  return getDerived().Transform##X##Attr(cast<X##Attr>(R));
7577#include "clang/Basic/AttrList.inc"
}
return R;
7580}

7582template <typename Derived>
7583const Attr *TreeTransform<Derived>::TransformStmtAttr(const Stmt *OrigS,
                                                    const Stmt *InstS,
                                                    const Attr *R) {
if (!R)
  return R;

switch (R->getKind()) {
7590// Transform attributes by calling TransformStmtXXXAttr.
7591#define ATTR(X)                                                                \
case attr::X:                                                                \
  return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R));
7594#include "clang/Basic/AttrList.inc"
}
return TransformAttr(R);
7597}

7599template <typename Derived>
7600StmtResult
7601TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S,
                                              StmtDiscardKind SDK) {
StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
if (SubStmt.isInvalid())
  return StmtError();

bool AttrsChanged = false;
SmallVector<const Attr *, 1> Attrs;

// Visit attributes and keep track if any are transformed.
for (const auto *I : S->getAttrs()) {
  const Attr *R =
      getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.get(), I);
  AttrsChanged |= (I != R);
  if (R)
    Attrs.push_back(R);
}

if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
  return S;

// If transforming the attributes failed for all of the attributes in the
// statement, don't make an AttributedStmt without attributes.
if (Attrs.empty())
  return SubStmt;

return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
                                          SubStmt.get());
7629}

7631template<typename Derived>
7632StmtResult
7633TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

Sema::ConditionResult Cond;
if (!S->isConsteval()) {
  // Transform the condition
  Cond = getDerived().TransformCondition(
      S->getIfLoc(), S->getConditionVariable(), S->getCond(),
      S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
                       : Sema::ConditionKind::Boolean);
  if (Cond.isInvalid())
    return StmtError();
}

// If this is a constexpr if, determine which arm we should instantiate.
std::optional<bool> ConstexprConditionValue;
if (S->isConstexpr())
  ConstexprConditionValue = Cond.getKnownValue();

// Transform the "then" branch.
StmtResult Then;
if (!ConstexprConditionValue || *ConstexprConditionValue) {
  Then = getDerived().TransformStmt(S->getThen());
  if (Then.isInvalid())
    return StmtError();
} else {
  Then = new (getSema().Context) NullStmt(S->getThen()->getBeginLoc());
}

// Transform the "else" branch.
StmtResult Else;
if (!ConstexprConditionValue || !*ConstexprConditionValue) {
  Else = getDerived().TransformStmt(S->getElse());
  if (Else.isInvalid())
    return StmtError();
}

if (!getDerived().AlwaysRebuild() &&
    Init.get() == S->getInit() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Then.get() == S->getThen() &&
    Else.get() == S->getElse())
  return S;

return getDerived().RebuildIfStmt(
    S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
    S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get());
7683}

7685template<typename Derived>
7686StmtResult
7687TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// Transform the condition.
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Switch);
if (Cond.isInvalid())
  return StmtError();

// Rebuild the switch statement.
StmtResult Switch =
    getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
                                        Init.get(), Cond, S->getRParenLoc());
if (Switch.isInvalid())
  return StmtError();

// Transform the body of the switch statement.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Complete the switch statement.
return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
                                          Body.get());
7715}

7717template<typename Derived>
7718StmtResult
7719TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Body.get() == S->getBody())
  return Owned(S);

return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
                                     Cond, S->getRParenLoc(), Body.get());
7739}

7741template<typename Derived>
7742StmtResult
7743TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Transform the condition
ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == S->getCond() &&
    Body.get() == S->getBody())
  return S;

return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
                                  /*FIXME:*/S->getWhileLoc(), Cond.get(),
                                  S->getRParenLoc());
7762}

7764template<typename Derived>
7765StmtResult
7766TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
if (getSema().getLangOpts().OpenMP)
  getSema().startOpenMPLoop();

// Transform the initialization statement
StmtResult Init = getDerived().TransformStmt(S->getInit());
if (Init.isInvalid())
  return StmtError();

// In OpenMP loop region loop control variable must be captured and be
// private. Perform analysis of first part (if any).
if (getSema().getLangOpts().OpenMP && Init.isUsable())
  getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());

// Transform the condition
Sema::ConditionResult Cond = getDerived().TransformCondition(
    S->getForLoc(), S->getConditionVariable(), S->getCond(),
    Sema::ConditionKind::Boolean);
if (Cond.isInvalid())
  return StmtError();

// Transform the increment
ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
  return StmtError();

Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
if (S->getInc() && !FullInc.get())
  return StmtError();

// Transform the body
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() &&
    Init.get() == S->getInit() &&
    Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
    Inc.get() == S->getInc() &&
    Body.get() == S->getBody())
  return S;

return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
                                   Init.get(), Cond, FullInc,
                                   S->getRParenLoc(), Body.get());
7811}

7813template<typename Derived>
7814StmtResult
7815TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
                                      S->getLabel());
if (!LD)
  return StmtError();

// Goto statements must always be rebuilt, to resolve the label.
return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
                                    cast<LabelDecl>(LD));
7824}

7826template<typename Derived>
7827StmtResult
7828TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
ExprResult Target = getDerived().TransformExpr(S->getTarget());
if (Target.isInvalid())
  return StmtError();
Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());

if (!getDerived().AlwaysRebuild() &&
    Target.get() == S->getTarget())
  return S;

return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
                                            Target.get());
7840}

7842template<typename Derived>
7843StmtResult
7844TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
return S;
7846}

7848template<typename Derived>
7849StmtResult
7850TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
return S;
7852}

7854template<typename Derived>
7855StmtResult
7856TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return StmtError();

// FIXME: We always rebuild the return statement because there is no way
// to tell whether the return type of the function has changed.
return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
7865}

7867template<typename Derived>
7868StmtResult
7869TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
bool DeclChanged = false;
SmallVector<Decl *, 4> Decls;
for (auto *D : S->decls()) {
  Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
  if (!Transformed)
    return StmtError();

  if (Transformed != D)
    DeclChanged = true;

  Decls.push_back(Transformed);
}

if (!getDerived().AlwaysRebuild() && !DeclChanged)
  return S;

return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
7887}

7889template<typename Derived>
7890StmtResult
7891TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {

SmallVector<Expr*, 8> Constraints;
SmallVector<Expr*, 8> Exprs;
SmallVector<IdentifierInfo *, 4> Names;

ExprResult AsmString;
SmallVector<Expr*, 8> Clobbers;

bool ExprsChanged = false;

// Go through the outputs.
for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
  Names.push_back(S->getOutputIdentifier(I));

  // No need to transform the constraint literal.
  Constraints.push_back(S->getOutputConstraintLiteral(I));

  // Transform the output expr.
  Expr *OutputExpr = S->getOutputExpr(I);
  ExprResult Result = getDerived().TransformExpr(OutputExpr);
  if (Result.isInvalid())
    return StmtError();

  ExprsChanged |= Result.get() != OutputExpr;

  Exprs.push_back(Result.get());
}

// Go through the inputs.
for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
  Names.push_back(S->getInputIdentifier(I));

  // No need to transform the constraint literal.
  Constraints.push_back(S->getInputConstraintLiteral(I));

  // Transform the input expr.
  Expr *InputExpr = S->getInputExpr(I);
  ExprResult Result = getDerived().TransformExpr(InputExpr);
  if (Result.isInvalid())
    return StmtError();

  ExprsChanged |= Result.get() != InputExpr;

  Exprs.push_back(Result.get());
}

// Go through the Labels.
for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
  Names.push_back(S->getLabelIdentifier(I));

  ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I));
  if (Result.isInvalid())
    return StmtError();
  ExprsChanged |= Result.get() != S->getLabelExpr(I);
  Exprs.push_back(Result.get());
}
if (!getDerived().AlwaysRebuild() && !ExprsChanged)
  return S;

// Go through the clobbers.
for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
  Clobbers.push_back(S->getClobberStringLiteral(I));

// No need to transform the asm string literal.
AsmString = S->getAsmString();
return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
                                      S->isVolatile(), S->getNumOutputs(),
                                      S->getNumInputs(), Names.data(),
                                      Constraints, Exprs, AsmString.get(),
                                      Clobbers, S->getNumLabels(),
                                      S->getRParenLoc());
7963}

7965template<typename Derived>
7966StmtResult
7967TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks());

bool HadError = false, HadChange = false;

ArrayRef<Expr*> SrcExprs = S->getAllExprs();
SmallVector<Expr*, 8> TransformedExprs;
TransformedExprs.reserve(SrcExprs.size());
for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
  ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
  if (!Result.isUsable()) {
    HadError = true;
  } else {
    HadChange |= (Result.get() != SrcExprs[i]);
    TransformedExprs.push_back(Result.get());
  }
}

if (HadError) return StmtError();
if (!HadChange && !getDerived().AlwaysRebuild())
  return Owned(S);

return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
                                     AsmToks, S->getAsmString(),
                                     S->getNumOutputs(), S->getNumInputs(),
                                     S->getAllConstraints(), S->getClobbers(),
                                     TransformedExprs, S->getEndLoc());
7994}

7996// C++ Coroutines
7997template<typename Derived>
7998StmtResult
7999TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
auto *ScopeInfo = SemaRef.getCurFunction();
auto *FD = cast<FunctionDecl>(SemaRef.CurContext);
assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       ScopeInfo->NeedsCoroutineSuspends &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       ScopeInfo->CoroutineSuspends.first == nullptr &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       ScopeInfo->CoroutineSuspends.second == nullptr &&(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
))
       "expected clean scope info")(static_cast <bool> (FD && ScopeInfo &&
 !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends
 && ScopeInfo->CoroutineSuspends.first == nullptr &&
 ScopeInfo->CoroutineSuspends.second == nullptr &&
 "expected clean scope info") ? void (0) : __assert_fail ("FD && ScopeInfo && !ScopeInfo->CoroutinePromise && ScopeInfo->NeedsCoroutineSuspends && ScopeInfo->CoroutineSuspends.first == nullptr && ScopeInfo->CoroutineSuspends.second == nullptr && \"expected clean scope info\""
, "clang/lib/Sema/TreeTransform.h", 8006, __extension__ __PRETTY_FUNCTION__
));

// Set that we have (possibly-invalid) suspend points before we do anything
// that may fail.
ScopeInfo->setNeedsCoroutineSuspends(false);

// We re-build the coroutine promise object (and the coroutine parameters its
// type and constructor depend on) based on the types used in our current
// function. We must do so, and set it on the current FunctionScopeInfo,
// before attempting to transform the other parts of the coroutine body
// statement, such as the implicit suspend statements (because those
// statements reference the FunctionScopeInfo::CoroutinePromise).
if (!SemaRef.buildCoroutineParameterMoves(FD->getLocation()))
  return StmtError();
auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation());
if (!Promise)
  return StmtError();
getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
ScopeInfo->CoroutinePromise = Promise;

// Transform the implicit coroutine statements constructed using dependent
// types during the previous parse: initial and final suspensions, the return
// object, and others. We also transform the coroutine function's body.
StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
if (InitSuspend.isInvalid())
  return StmtError();
StmtResult FinalSuspend =
    getDerived().TransformStmt(S->getFinalSuspendStmt());
if (FinalSuspend.isInvalid() ||
    !SemaRef.checkFinalSuspendNoThrow(FinalSuspend.get()))
  return StmtError();
ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()))(static_cast <bool> (isa<Expr>(InitSuspend.get())
 && isa<Expr>(FinalSuspend.get())) ? void (0) :
 __assert_fail ("isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get())"
, "clang/lib/Sema/TreeTransform.h", 8038, __extension__ __PRETTY_FUNCTION__
));

StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
if (BodyRes.isInvalid())
  return StmtError();

CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
if (Builder.isInvalid())
  return StmtError();

Expr *ReturnObject = S->getReturnValueInit();
assert(ReturnObject && "the return object is expected to be valid")(static_cast <bool> (ReturnObject && "the return object is expected to be valid"
) ? void (0) : __assert_fail ("ReturnObject && \"the return object is expected to be valid\""
, "clang/lib/Sema/TreeTransform.h", 8049, __extension__ __PRETTY_FUNCTION__
));
ExprResult Res = getDerived().TransformInitializer(ReturnObject,
                                                   /*NoCopyInit*/ false);
if (Res.isInvalid())
  return StmtError();
Builder.ReturnValue = Res.get();

// If during the previous parse the coroutine still had a dependent promise
// statement, we may need to build some implicit coroutine statements
// (such as exception and fallthrough handlers) for the first time.
if (S->hasDependentPromiseType()) {
  // We can only build these statements, however, if the current promise type
  // is not dependent.
  if (!Promise->getType()->isDependentType()) {
    assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&(static_cast <bool> (!S->getFallthroughHandler() &&
 !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure
() && !S->getDeallocate() && "these nodes should not have been built yet"
) ? void (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "clang/lib/Sema/TreeTransform.h", 8065, __extension__ __PRETTY_FUNCTION__
))
           !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&(static_cast <bool> (!S->getFallthroughHandler() &&
 !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure
() && !S->getDeallocate() && "these nodes should not have been built yet"
) ? void (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "clang/lib/Sema/TreeTransform.h", 8065, __extension__ __PRETTY_FUNCTION__
))
           "these nodes should not have been built yet")(static_cast <bool> (!S->getFallthroughHandler() &&
 !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure
() && !S->getDeallocate() && "these nodes should not have been built yet"
) ? void (0) : __assert_fail ("!S->getFallthroughHandler() && !S->getExceptionHandler() && !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() && \"these nodes should not have been built yet\""
, "clang/lib/Sema/TreeTransform.h", 8065, __extension__ __PRETTY_FUNCTION__
));
    if (!Builder.buildDependentStatements())
      return StmtError();
  }
} else {
  if (auto *OnFallthrough = S->getFallthroughHandler()) {
    StmtResult Res = getDerived().TransformStmt(OnFallthrough);
    if (Res.isInvalid())
      return StmtError();
    Builder.OnFallthrough = Res.get();
  }

  if (auto *OnException = S->getExceptionHandler()) {
    StmtResult Res = getDerived().TransformStmt(OnException);
    if (Res.isInvalid())
      return StmtError();
    Builder.OnException = Res.get();
  }

  if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
    StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
    if (Res.isInvalid())
      return StmtError();
    Builder.ReturnStmtOnAllocFailure = Res.get();
  }

  // Transform any additional statements we may have already built
  assert(S->getAllocate() && S->getDeallocate() &&(static_cast <bool> (S->getAllocate() && S->
getDeallocate() && "allocation and deallocation calls must already be built"
) ? void (0) : __assert_fail ("S->getAllocate() && S->getDeallocate() && \"allocation and deallocation calls must already be built\""
, "clang/lib/Sema/TreeTransform.h", 8093, __extension__ __PRETTY_FUNCTION__
))
         "allocation and deallocation calls must already be built")(static_cast <bool> (S->getAllocate() && S->
getDeallocate() && "allocation and deallocation calls must already be built"
) ? void (0) : __assert_fail ("S->getAllocate() && S->getDeallocate() && \"allocation and deallocation calls must already be built\""
, "clang/lib/Sema/TreeTransform.h", 8093, __extension__ __PRETTY_FUNCTION__
));
  ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
  if (AllocRes.isInvalid())
    return StmtError();
  Builder.Allocate = AllocRes.get();

  ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
  if (DeallocRes.isInvalid())
    return StmtError();
  Builder.Deallocate = DeallocRes.get();

  if (auto *ResultDecl = S->getResultDecl()) {
    StmtResult Res = getDerived().TransformStmt(ResultDecl);
    if (Res.isInvalid())
      return StmtError();
    Builder.ResultDecl = Res.get();
  }

  if (auto *ReturnStmt = S->getReturnStmt()) {
    StmtResult Res = getDerived().TransformStmt(ReturnStmt);
    if (Res.isInvalid())
      return StmtError();
    Builder.ReturnStmt = Res.get();
  }
}

return getDerived().RebuildCoroutineBodyStmt(Builder);
8120}

8122template<typename Derived>
8123StmtResult
8124TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return StmtError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
                                        S->isImplicit());
8134}

8136template <typename Derived>
8137ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
ExprResult Operand = getDerived().TransformInitializer(E->getOperand(),
                                                       /*NotCopyInit*/ false);
if (Operand.isInvalid())
  return ExprError();

// Rebuild the common-expr from the operand rather than transforming it
// separately.

// FIXME: getCurScope() should not be used during template instantiation.
// We should pick up the set of unqualified lookup results for operator
// co_await during the initial parse.
ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
    getSema().getCurScope(), E->getKeywordLoc());

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoawaitExpr(
    E->getKeywordLoc(), Operand.get(),
    cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit());
8157}

8159template <typename Derived>
8160ExprResult
8161TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) {
ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/ false);
if (OperandResult.isInvalid())
  return ExprError();

ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
        E->getOperatorCoawaitLookup());

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

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildDependentCoawaitExpr(
    E->getKeywordLoc(), OperandResult.get(),
    cast<UnresolvedLookupExpr>(LookupResult.get()));
8178}

8180template<typename Derived>
8181ExprResult
8182TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
                                                      /*NotCopyInit*/false);
if (Result.isInvalid())
  return ExprError();

// Always rebuild; we don't know if this needs to be injected into a new
// context or if the promise type has changed.
return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
8191}

8193// Objective-C Statements.

8195template<typename Derived>
8196StmtResult
8197TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
// Transform the body of the @try.
StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
if (TryBody.isInvalid())
  return StmtError();

// Transform the @catch statements (if present).
bool AnyCatchChanged = false;
SmallVector<Stmt*, 8> CatchStmts;
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
  StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
  if (Catch.isInvalid())
    return StmtError();
  if (Catch.get() != S->getCatchStmt(I))
    AnyCatchChanged = true;
  CatchStmts.push_back(Catch.get());
}

// Transform the @finally statement (if present).
StmtResult Finally;
if (S->getFinallyStmt()) {
  Finally = getDerived().TransformStmt(S->getFinallyStmt());
  if (Finally.isInvalid())
    return StmtError();
}

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    TryBody.get() == S->getTryBody() &&
    !AnyCatchChanged &&
    Finally.get() == S->getFinallyStmt())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
                                         CatchStmts, Finally.get());
8233}

8235template<typename Derived>
8236StmtResult
8237TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
// Transform the @catch parameter, if there is one.
VarDecl *Var = nullptr;
if (VarDecl *FromVar = S->getCatchParamDecl()) {
  TypeSourceInfo *TSInfo = nullptr;
  if (FromVar->getTypeSourceInfo()) {
    TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
    if (!TSInfo)
      return StmtError();
  }

  QualType T;
  if (TSInfo)
    T = TSInfo->getType();
  else {
    T = getDerived().TransformType(FromVar->getType());
    if (T.isNull())
      return StmtError();
  }

  Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
  if (!Var)
    return StmtError();
}

StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
if (Body.isInvalid())
  return StmtError();

return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
                                           S->getRParenLoc(),
                                           Var, Body.get());
8269}

8271template<typename Derived>
8272StmtResult
8273TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Body.get() == S->getFinallyBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
                                             Body.get());
8287}

8289template<typename Derived>
8290StmtResult
8291TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
ExprResult Operand;
if (S->getThrowExpr()) {
  Operand = getDerived().TransformExpr(S->getThrowExpr());
  if (Operand.isInvalid())
    return StmtError();
}

if (!getDerived().AlwaysRebuild() &&
    Operand.get() == S->getThrowExpr())
  return S;

return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
8304}

8306template<typename Derived>
8307StmtResult
8308TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
                                                ObjCAtSynchronizedStmt *S) {
// Transform the object we are locking.
ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
if (Object.isInvalid())
  return StmtError();
Object =
  getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
                                                Object.get());
if (Object.isInvalid())
  return StmtError();

// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
if (Body.isInvalid())
  return StmtError();

// If nothing change, just retain the current statement.
if (!getDerived().AlwaysRebuild() &&
    Object.get() == S->getSynchExpr() &&
    Body.get() == S->getSynchBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
                                                  Object.get(), Body.get());
8334}

8336template<typename Derived>
8337StmtResult
8338TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
                                            ObjCAutoreleasePoolStmt *S) {
// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Body.get() == S->getSubStmt())
  return S;

// Build a new statement.
return getDerived().RebuildObjCAutoreleasePoolStmt(
                      S->getAtLoc(), Body.get());
8353}

8355template<typename Derived>
8356StmtResult
8357TreeTransform<Derived>::TransformObjCForCollectionStmt(
                                                ObjCForCollectionStmt *S) {
// Transform the element statement.
StmtResult Element =
    getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
if (Element.isInvalid())
  return StmtError();

// Transform the collection expression.
ExprResult Collection = getDerived().TransformExpr(S->getCollection());
if (Collection.isInvalid())
  return StmtError();

// Transform the body.
StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// If nothing changed, just retain this statement.
if (!getDerived().AlwaysRebuild() &&
    Element.get() == S->getElement() &&
    Collection.get() == S->getCollection() &&
    Body.get() == S->getBody())
  return S;

// Build a new statement.
return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
                                                 Element.get(),
                                                 Collection.get(),
                                                 S->getRParenLoc(),
                                                 Body.get());
8388}

8390template <typename Derived>
8391StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
// Transform the exception declaration, if any.
VarDecl *Var = nullptr;
if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
  TypeSourceInfo *T =
      getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
  if (!T)
    return StmtError();

  Var = getDerived().RebuildExceptionDecl(
      ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
      ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
  if (!Var || Var->isInvalidDecl())
    return StmtError();
}

// Transform the actual exception handler.
StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
if (Handler.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() && !Var &&
    Handler.get() == S->getHandlerBlock())
  return S;

return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
8417}

8419template <typename Derived>
8420StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
// Transform the try block itself.
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
  return StmtError();

// Transform the handlers.
bool HandlerChanged = false;
SmallVector<Stmt *, 8> Handlers;
for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
  StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
  if (Handler.isInvalid())
    return StmtError();

  HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
  Handlers.push_back(Handler.getAs<Stmt>());
}

if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
    !HandlerChanged)
  return S;

return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
                                      Handlers);
8444}

8446template<typename Derived>
8447StmtResult
8448TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
StmtResult Init =
    S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
if (Init.isInvalid())
  return StmtError();

StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
if (Range.isInvalid())
  return StmtError();

StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
if (Begin.isInvalid())
  return StmtError();
StmtResult End = getDerived().TransformStmt(S->getEndStmt());
if (End.isInvalid())
  return StmtError();

ExprResult Cond = getDerived().TransformExpr(S->getCond());
if (Cond.isInvalid())
  return StmtError();
if (Cond.get())
  Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
if (Cond.isInvalid())
  return StmtError();
if (Cond.get())
  Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());

ExprResult Inc = getDerived().TransformExpr(S->getInc());
if (Inc.isInvalid())
  return StmtError();
if (Inc.get())
  Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());

StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
if (LoopVar.isInvalid())
  return StmtError();

StmtResult NewStmt = S;
if (getDerived().AlwaysRebuild() ||
    Init.get() != S->getInit() ||
    Range.get() != S->getRangeStmt() ||
    Begin.get() != S->getBeginStmt() ||
    End.get() != S->getEndStmt() ||
    Cond.get() != S->getCond() ||
    Inc.get() != S->getInc() ||
    LoopVar.get() != S->getLoopVarStmt()) {
  NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
                                                S->getCoawaitLoc(), Init.get(),
                                                S->getColonLoc(), Range.get(),
                                                Begin.get(), End.get(),
                                                Cond.get(),
                                                Inc.get(), LoopVar.get(),
                                                S->getRParenLoc());
  if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
    // Might not have attached any initializer to the loop variable.
    getSema().ActOnInitializerError(
        cast<DeclStmt>(LoopVar.get())->getSingleDecl());
    return StmtError();
  }
}

StmtResult Body = getDerived().TransformStmt(S->getBody());
if (Body.isInvalid())
  return StmtError();

// Body has changed but we didn't rebuild the for-range statement. Rebuild
// it now so we have a new statement to attach the body to.
if (Body.get() != S->getBody() && NewStmt.get() == S) {
  NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
                                                S->getCoawaitLoc(), Init.get(),
                                                S->getColonLoc(), Range.get(),
                                                Begin.get(), End.get(),
                                                Cond.get(),
                                                Inc.get(), LoopVar.get(),
                                                S->getRParenLoc());
  if (NewStmt.isInvalid())
    return StmtError();
}

if (NewStmt.get() == S)
  return S;

return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
8531}

8533template<typename Derived>
8534StmtResult
8535TreeTransform<Derived>::TransformMSDependentExistsStmt(
                                                  MSDependentExistsStmt *S) {
// Transform the nested-name-specifier, if any.
NestedNameSpecifierLoc QualifierLoc;
if (S->getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
  if (!QualifierLoc)
    return StmtError();
}

// Transform the declaration name.
DeclarationNameInfo NameInfo = S->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return StmtError();
}

// Check whether anything changed.
if (!getDerived().AlwaysRebuild() &&
    QualifierLoc == S->getQualifierLoc() &&
    NameInfo.getName() == S->getNameInfo().getName())
  return S;

// Determine whether this name exists, if we can.
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);
bool Dependent = false;
switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
case Sema::IER_Exists:
  if (S->isIfExists())
    break;

  return new (getSema().Context) NullStmt(S->getKeywordLoc());

case Sema::IER_DoesNotExist:
  if (S->isIfNotExists())
    break;

  return new (getSema().Context) NullStmt(S->getKeywordLoc());

case Sema::IER_Dependent:
  Dependent = true;
  break;

case Sema::IER_Error:
  return StmtError();
}

// We need to continue with the instantiation, so do so now.
StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
if (SubStmt.isInvalid())
  return StmtError();

// If we have resolved the name, just transform to the substatement.
if (!Dependent)
  return SubStmt;

// The name is still dependent, so build a dependent expression again.
return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
                                                 S->isIfExists(),
                                                 QualifierLoc,
                                                 NameInfo,
                                                 SubStmt.get());
8600}

8602template<typename Derived>
8603ExprResult
8604TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifierLoc()) {
  QualifierLoc
  = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
  getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
if (!PD)
  return ExprError();

ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
  return ExprError();

return new (SemaRef.getASTContext())
    MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
                      SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
                      QualifierLoc, E->getMemberLoc());
8626}

8628template <typename Derived>
8629ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
  MSPropertySubscriptExpr *E) {
auto BaseRes = getDerived().TransformExpr(E->getBase());
if (BaseRes.isInvalid())
  return ExprError();
auto IdxRes = getDerived().TransformExpr(E->getIdx());
if (IdxRes.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    BaseRes.get() == E->getBase() &&
    IdxRes.get() == E->getIdx())
  return E;

return getDerived().RebuildArraySubscriptExpr(
    BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
8645}

8647template <typename Derived>
8648StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
if (TryBlock.isInvalid())
  return StmtError();

StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
if (Handler.isInvalid())
  return StmtError();

if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
    Handler.get() == S->getHandler())
  return S;

return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
                                      TryBlock.get(), Handler.get());
8663}

8665template <typename Derived>
8666StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
  return StmtError();

return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
8672}

8674template <typename Derived>
8675StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
if (FilterExpr.isInvalid())
  return StmtError();

StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
if (Block.isInvalid())
  return StmtError();

return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
                                         Block.get());
8686}

8688template <typename Derived>
8689StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
if (isa<SEHFinallyStmt>(Handler))
  return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
else
  return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
8694}

8696template<typename Derived>
8697StmtResult
8698TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
return S;
8700}

8702//===----------------------------------------------------------------------===//
8703// OpenMP directive transformation
8704//===----------------------------------------------------------------------===//

8706template <typename Derived>
8707StmtResult
8708TreeTransform<Derived>::TransformOMPCanonicalLoop(OMPCanonicalLoop *L) {
// OMPCanonicalLoops are eliminated during transformation, since they will be
// recomputed by semantic analysis of the associated OMPLoopBasedDirective
// after transformation.
return getDerived().TransformStmt(L->getLoopStmt());
8713}

8715template <typename Derived>
8716StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
  OMPExecutableDirective *D) {

// Transform the clauses
llvm::SmallVector<OMPClause *, 16> TClauses;
ArrayRef<OMPClause *> Clauses = D->clauses();
TClauses.reserve(Clauses.size());
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
     I != E; ++I) {
  if (*I) {
    getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
    OMPClause *Clause = getDerived().TransformOMPClause(*I);
    getDerived().getSema().EndOpenMPClause();
    if (Clause)
      TClauses.push_back(Clause);
  } else {
    TClauses.push_back(nullptr);
  }
}
StmtResult AssociatedStmt;
if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
  getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(),
                                                /*CurScope=*/nullptr);
  StmtResult Body;
  {
    Sema::CompoundScopeRAII CompoundScope(getSema());
    Stmt *CS;
    if (D->getDirectiveKind() == OMPD_atomic ||
        D->getDirectiveKind() == OMPD_critical ||
        D->getDirectiveKind() == OMPD_section ||
        D->getDirectiveKind() == OMPD_master)
      CS = D->getAssociatedStmt();
    else
      CS = D->getRawStmt();
    Body = getDerived().TransformStmt(CS);
    if (Body.isUsable() && isOpenMPLoopDirective(D->getDirectiveKind()) &&
        getSema().getLangOpts().OpenMPIRBuilder)
      Body = getDerived().RebuildOMPCanonicalLoop(Body.get());
  }
  AssociatedStmt =
      getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
  if (AssociatedStmt.isInvalid()) {
    return StmtError();
  }
}
if (TClauses.size() != Clauses.size()) {
  return StmtError();
}

// Transform directive name for 'omp critical' directive.
DeclarationNameInfo DirName;
if (D->getDirectiveKind() == OMPD_critical) {
  DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
  DirName = getDerived().TransformDeclarationNameInfo(DirName);
}
OpenMPDirectiveKind CancelRegion = OMPD_unknown;
if (D->getDirectiveKind() == OMPD_cancellation_point) {
  CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
} else if (D->getDirectiveKind() == OMPD_cancel) {
  CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
}

return getDerived().RebuildOMPExecutableDirective(
    D->getDirectiveKind(), DirName, CancelRegion, TClauses,
    AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc());
8781}

8783template <typename Derived>
8784StmtResult
8785TreeTransform<Derived>::TransformOMPMetaDirective(OMPMetaDirective *D) {
// TODO: Fix This
SemaRef.Diag(D->getBeginLoc(), diag::err_omp_instantiation_not_supported)
    << getOpenMPDirectiveName(D->getDirectiveKind());
return StmtError();
8790}

8792template <typename Derived>
8793StmtResult
8794TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8801}

8803template <typename Derived>
8804StmtResult
8805TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8812}

8814template <typename Derived>
8815StmtResult
8816TreeTransform<Derived>::TransformOMPTileDirective(OMPTileDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(D->getDirectiveKind(), DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8823}

8825template <typename Derived>
8826StmtResult
8827TreeTransform<Derived>::TransformOMPUnrollDirective(OMPUnrollDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(D->getDirectiveKind(), DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8834}

8836template <typename Derived>
8837StmtResult
8838TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8845}

8847template <typename Derived>
8848StmtResult
8849TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8856}

8858template <typename Derived>
8859StmtResult
8860TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8867}

8869template <typename Derived>
8870StmtResult
8871TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8878}

8880template <typename Derived>
8881StmtResult
8882TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8889}

8891template <typename Derived>
8892StmtResult
8893TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8900}

8902template <typename Derived>
8903StmtResult
8904TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8910}

8912template <typename Derived>
8913StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
  OMPParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8921}

8923template <typename Derived>
8924StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
  OMPParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8932}

8934template <typename Derived>
8935StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective(
  OMPParallelMasterDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_master, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8943}

8945template <typename Derived>
8946StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective(
  OMPParallelMaskedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_masked, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8954}

8956template <typename Derived>
8957StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
  OMPParallelSectionsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8965}

8967template <typename Derived>
8968StmtResult
8969TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8976}

8978template <typename Derived>
8979StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
  OMPTaskyieldDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8987}

8989template <typename Derived>
8990StmtResult
8991TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
8998}

9000template <typename Derived>
9001StmtResult
9002TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9009}

9011template <typename Derived>
9012StmtResult
9013TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_error, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9020}

9022template <typename Derived>
9023StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
  OMPTaskgroupDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9031}

9033template <typename Derived>
9034StmtResult
9035TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9042}

9044template <typename Derived>
9045StmtResult
9046TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_depobj, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9053}

9055template <typename Derived>
9056StmtResult
9057TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_scan, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9064}

9066template <typename Derived>
9067StmtResult
9068TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9075}

9077template <typename Derived>
9078StmtResult
9079TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9086}

9088template <typename Derived>
9089StmtResult
9090TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9097}

9099template <typename Derived>
9100StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
  OMPTargetDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9108}

9110template <typename Derived>
9111StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
  OMPTargetEnterDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9119}

9121template <typename Derived>
9122StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
  OMPTargetExitDataDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9130}

9132template <typename Derived>
9133StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
  OMPTargetParallelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9141}

9143template <typename Derived>
9144StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
  OMPTargetParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9152}

9154template <typename Derived>
9155StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
  OMPTargetUpdateDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9163}

9165template <typename Derived>
9166StmtResult
9167TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9174}

9176template <typename Derived>
9177StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
  OMPCancellationPointDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9185}

9187template <typename Derived>
9188StmtResult
9189TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9196}

9198template <typename Derived>
9199StmtResult
9200TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9207}

9209template <typename Derived>
9210StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
  OMPTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9218}

9220template <typename Derived>
9221StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective(
  OMPMasterTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master_taskloop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9229}

9231template <typename Derived>
9232StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective(
  OMPMaskedTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9240}

9242template <typename Derived>
9243StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
  OMPMasterTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_master_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9251}

9253template <typename Derived>
9254StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
  OMPMaskedTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9262}

9264template <typename Derived>
9265StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
  OMPParallelMasterTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_master_taskloop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9273}

9275template <typename Derived>
9276StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective(
  OMPParallelMaskedTaskLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_masked_taskloop, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9284}

9286template <typename Derived>
9287StmtResult
9288TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective(
  OMPParallelMasterTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9296}

9298template <typename Derived>
9299StmtResult
9300TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective(
  OMPParallelMaskedTaskLoopSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_parallel_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9308}

9310template <typename Derived>
9311StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
  OMPDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9319}

9321template <typename Derived>
9322StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
  OMPDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9330}

9332template <typename Derived>
9333StmtResult
9334TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
  OMPDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9342}

9344template <typename Derived>
9345StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
  OMPDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9353}

9355template <typename Derived>
9356StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
  OMPTargetParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9364}

9366template <typename Derived>
9367StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
  OMPTargetSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_simd, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9375}

9377template <typename Derived>
9378StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
  OMPTeamsDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9386}

9388template <typename Derived>
9389StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
  OMPTeamsDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9397}

9399template <typename Derived>
9400StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
  OMPTeamsDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_parallel_for_simd, DirName, nullptr,
    D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9409}

9411template <typename Derived>
9412StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
  OMPTeamsDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9420}

9422template <typename Derived>
9423StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
  OMPTargetTeamsDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams, DirName,
                                           nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9431}

9433template <typename Derived>
9434StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
  OMPTargetTeamsDistributeDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9442}

9444template <typename Derived>
9445StmtResult
9446TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
  OMPTargetTeamsDistributeParallelForDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_parallel_for, DirName, nullptr,
    D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9455}

9457template <typename Derived>
9458StmtResult TreeTransform<Derived>::
  TransformOMPTargetTeamsDistributeParallelForSimdDirective(
      OMPTargetTeamsDistributeParallelForSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr,
    D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9468}

9470template <typename Derived>
9471StmtResult
9472TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
  OMPTargetTeamsDistributeSimdDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(
    OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
auto Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9480}

9482template <typename Derived>
9483StmtResult
9484TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_interop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9491}

9493template <typename Derived>
9494StmtResult
9495TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_dispatch, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9502}

9504template <typename Derived>
9505StmtResult
9506TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9513}

9515template <typename Derived>
9516StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective(
  OMPGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_loop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9524}

9526template <typename Derived>
9527StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective(
  OMPTeamsGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_loop, DirName, nullptr,
                                           D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9535}

9537template <typename Derived>
9538StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective(
  OMPTargetTeamsGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams_loop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9546}

9548template <typename Derived>
9549StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective(
  OMPParallelGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_loop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9557}

9559template <typename Derived>
9560StmtResult
9561TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective(
  OMPTargetParallelGenericLoopDirective *D) {
DeclarationNameInfo DirName;
getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_loop, DirName,
                                           nullptr, D->getBeginLoc());
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
9569}

9571//===----------------------------------------------------------------------===//
9572// OpenMP clause transformation
9573//===----------------------------------------------------------------------===//
9574template <typename Derived>
9575OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPIfClause(
    C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc());
9582}

9584template <typename Derived>
9585OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
9591}

9593template <typename Derived>
9594OMPClause *
9595TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
if (NumThreads.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumThreadsClause(
    NumThreads.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9601}

9603template <typename Derived>
9604OMPClause *
9605TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSafelen());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPSafelenClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9611}

9613template <typename Derived>
9614OMPClause *
9615TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *C) {
ExprResult E = getDerived().TransformExpr(C->getAllocator());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAllocatorClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9621}

9623template <typename Derived>
9624OMPClause *
9625TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
ExprResult E = getDerived().TransformExpr(C->getSimdlen());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPSimdlenClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9631}

9633template <typename Derived>
9634OMPClause *TreeTransform<Derived>::TransformOMPSizesClause(OMPSizesClause *C) {
SmallVector<Expr *, 4> TransformedSizes;
TransformedSizes.reserve(C->getNumSizes());
bool Changed = false;
for (Expr *E : C->getSizesRefs()) {
  if (!E) {
    TransformedSizes.push_back(nullptr);
    continue;
  }

  ExprResult T = getDerived().TransformExpr(E);
  if (T.isInvalid())
    return nullptr;
  if (E != T.get())
    Changed = true;
  TransformedSizes.push_back(T.get());
}

if (!Changed && !getDerived().AlwaysRebuild())
  return C;
return RebuildOMPSizesClause(TransformedSizes, C->getBeginLoc(),
                             C->getLParenLoc(), C->getEndLoc());
9656}

9658template <typename Derived>
9659OMPClause *TreeTransform<Derived>::TransformOMPFullClause(OMPFullClause *C) {
if (!getDerived().AlwaysRebuild())
  return C;
return RebuildOMPFullClause(C->getBeginLoc(), C->getEndLoc());
9663}

9665template <typename Derived>
9666OMPClause *
9667TreeTransform<Derived>::TransformOMPPartialClause(OMPPartialClause *C) {
ExprResult T = getDerived().TransformExpr(C->getFactor());
if (T.isInvalid())
  return nullptr;
Expr *Factor = T.get();
bool Changed = Factor != C->getFactor();

if (!Changed && !getDerived().AlwaysRebuild())
  return C;
return RebuildOMPPartialClause(Factor, C->getBeginLoc(), C->getLParenLoc(),
                               C->getEndLoc());
9678}

9680template <typename Derived>
9681OMPClause *
9682TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPCollapseClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9688}

9690template <typename Derived>
9691OMPClause *
9692TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
return getDerived().RebuildOMPDefaultClause(
    C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
9696}

9698template <typename Derived>
9699OMPClause *
9700TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
return getDerived().RebuildOMPProcBindClause(
    C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
9704}

9706template <typename Derived>
9707OMPClause *
9708TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
ExprResult E = getDerived().TransformExpr(C->getChunkSize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPScheduleClause(
    C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
    C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
    C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
9717}

9719template <typename Derived>
9720OMPClause *
9721TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
ExprResult E;
if (auto *Num = C->getNumForLoops()) {
  E = getDerived().TransformExpr(Num);
  if (E.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(),
                                            C->getLParenLoc(), E.get());
9730}

9732template <typename Derived>
9733OMPClause *
9734TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *C) {
ExprResult E;
if (Expr *Evt = C->getEventHandler()) {
  E = getDerived().TransformExpr(Evt);
  if (E.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
9743}

9745template <typename Derived>
9746OMPClause *
9747TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9750}

9752template <typename Derived>
9753OMPClause *
9754TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9757}

9759template <typename Derived>
9760OMPClause *
9761TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9764}

9766template <typename Derived>
9767OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9770}

9772template <typename Derived>
9773OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9776}

9778template <typename Derived>
9779OMPClause *
9780TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9783}

9785template <typename Derived>
9786OMPClause *
9787TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9790}

9792template <typename Derived>
9793OMPClause *
9794TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9797}

9799template <typename Derived>
9800OMPClause *
9801TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9804}

9806template <typename Derived>
9807OMPClause *
9808TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9811}

9813template <typename Derived>
9814OMPClause *
9815TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9818}

9820template <typename Derived>
9821OMPClause *
9822TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9825}

9827template <typename Derived>
9828OMPClause *
9829TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9832}

9834template <typename Derived>
9835OMPClause *
9836TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9839}

9841template <typename Derived>
9842OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9845}

9847template <typename Derived>
9848OMPClause *
9849TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
9852}

9854template <typename Derived>
9855OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *C) {
ExprResult IVR = getDerived().TransformExpr(C->getInteropVar());
if (IVR.isInvalid())
  return nullptr;

OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync());
InteropInfo.PreferTypes.reserve(C->varlist_size() - 1);
for (Expr *E : llvm::drop_begin(C->varlists())) {
  ExprResult ER = getDerived().TransformExpr(cast<Expr>(E));
  if (ER.isInvalid())
    return nullptr;
  InteropInfo.PreferTypes.push_back(ER.get());
}
return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo,
                                         C->getBeginLoc(), C->getLParenLoc(),
                                         C->getVarLoc(), C->getEndLoc());
9871}

9873template <typename Derived>
9874OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *C) {
ExprResult ER = getDerived().TransformExpr(C->getInteropVar());
if (ER.isInvalid())
  return nullptr;
return getDerived().RebuildOMPUseClause(ER.get(), C->getBeginLoc(),
                                        C->getLParenLoc(), C->getVarLoc(),
                                        C->getEndLoc());
9881}

9883template <typename Derived>
9884OMPClause *
9885TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *C) {
ExprResult ER;
if (Expr *IV = C->getInteropVar()) {
  ER = getDerived().TransformExpr(IV);
  if (ER.isInvalid())
    return nullptr;
}
return getDerived().RebuildOMPDestroyClause(ER.get(), C->getBeginLoc(),
                                            C->getLParenLoc(), C->getVarLoc(),
                                            C->getEndLoc());
9895}

9897template <typename Derived>
9898OMPClause *
9899TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNovariantsClause(
    Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9905}

9907template <typename Derived>
9908OMPClause *
9909TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *C) {
ExprResult Cond = getDerived().TransformExpr(C->getCondition());
if (Cond.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNocontextClause(
    Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9915}

9917template <typename Derived>
9918OMPClause *
9919TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) {
ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID());
if (ThreadID.isInvalid())
  return nullptr;
return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
9925}

9927template <typename Derived>
9928OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *C) {
ExprResult E = getDerived().TransformExpr(C->getAlignment());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
9934}

9936template <typename Derived>
9937OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
  OMPUnifiedAddressClause *C) {
llvm_unreachable("unified_address clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("unified_address clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9939);
9940}

9942template <typename Derived>
9943OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
  OMPUnifiedSharedMemoryClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("unified_shared_memory clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9946)
    "unified_shared_memory clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("unified_shared_memory clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9946);
9947}

9949template <typename Derived>
9950OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
  OMPReverseOffloadClause *C) {
llvm_unreachable("reverse_offload clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("reverse_offload clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9952);
9953}

9955template <typename Derived>
9956OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
  OMPDynamicAllocatorsClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("dynamic_allocators clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9959)
    "dynamic_allocators clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("dynamic_allocators clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9959);
9960}

9962template <typename Derived>
9963OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
  OMPAtomicDefaultMemOrderClause *C) {
llvm_unreachable(::llvm::llvm_unreachable_internal("atomic_default_mem_order clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9966)
    "atomic_default_mem_order clause cannot appear in dependent context")::llvm::llvm_unreachable_internal("atomic_default_mem_order clause cannot appear in dependent context"
, "clang/lib/Sema/TreeTransform.h", 9966);
9967}

9969template <typename Derived>
9970OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *C) {
return getDerived().RebuildOMPAtClause(C->getAtKind(), C->getAtKindKwLoc(),
                                       C->getBeginLoc(), C->getLParenLoc(),
                                       C->getEndLoc());
9974}

9976template <typename Derived>
9977OMPClause *
9978TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *C) {
return getDerived().RebuildOMPSeverityClause(
    C->getSeverityKind(), C->getSeverityKindKwLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
9982}

9984template <typename Derived>
9985OMPClause *
9986TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) {
ExprResult E = getDerived().TransformExpr(C->getMessageString());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPMessageClause(
    C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(),
    C->getEndLoc());
9993}

9995template <typename Derived>
9996OMPClause *
9997TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPPrivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10008}

10010template <typename Derived>
10011OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
  OMPFirstprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPFirstprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10023}

10025template <typename Derived>
10026OMPClause *
10027TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPLastprivateClause(
    Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
10039}

10041template <typename Derived>
10042OMPClause *
10043TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
10054}

10056template <typename Derived>
10057OMPClause *
10058TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(
     UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
        NameInfo, /*ADL=*/true, ULE->isOverloaded(),
        Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPReductionClause(
    Vars, C->getModifier(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getColonLoc(), C->getEndLoc(),
    ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10102}

10104template <typename Derived>
10105OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
  OMPTaskReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
        /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPTaskReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10147}

10149template <typename Derived>
10150OMPClause *
10151TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
CXXScopeSpec ReductionIdScopeSpec;
ReductionIdScopeSpec.Adopt(C->getQualifierLoc());

DeclarationNameInfo NameInfo = C->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return nullptr;
}
// Build a list of all UDR decls with the same names ranged by the Scopes.
// The Scope boundary is a duplication of the previous decl.
llvm::SmallVector<Expr *, 16> UnresolvedReductions;
for (auto *E : C->reduction_ops()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
        SemaRef.Context, /*NamingClass=*/nullptr,
        ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
        /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
  } else
    UnresolvedReductions.push_back(nullptr);
}
return getDerived().RebuildOMPInReductionClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10192}

10194template <typename Derived>
10195OMPClause *
10196TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
ExprResult Step = getDerived().TransformExpr(C->getStep());
if (Step.isInvalid())
  return nullptr;
return getDerived().RebuildOMPLinearClause(
    Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(),
    C->getModifierLoc(), C->getColonLoc(), C->getEndLoc());
10211}

10213template <typename Derived>
10214OMPClause *
10215TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
if (Alignment.isInvalid())
  return nullptr;
return getDerived().RebuildOMPAlignedClause(
    Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getColonLoc(), C->getEndLoc());
10230}

10232template <typename Derived>
10233OMPClause *
10234TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
10245}

10247template <typename Derived>
10248OMPClause *
10249TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPCopyprivateClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10260}

10262template <typename Derived>
10263OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(),
                                          C->getLParenLoc(), C->getEndLoc());
10274}

10276template <typename Derived>
10277OMPClause *
10278TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *C) {
ExprResult E = getDerived().TransformExpr(C->getDepobj());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDepobjClause(E.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getEndLoc());
10284}

10286template <typename Derived>
10287OMPClause *
10288TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Expr *DepModifier = C->getModifier();
if (DepModifier) {
  ExprResult DepModRes = getDerived().TransformExpr(DepModifier);
  if (DepModRes.isInvalid())
    return nullptr;
  DepModifier = DepModRes.get();
}
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPDependClause(
    {C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(),
     C->getOmpAllMemoryLoc()},
    DepModifier, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10308}

10310template <typename Derived>
10311OMPClause *
10312TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
ExprResult E = getDerived().TransformExpr(C->getDevice());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDeviceClause(
    C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getEndLoc());
10319}

10321template <typename Derived, class T>
10322bool transformOMPMappableExprListClause(
  TreeTransform<Derived> &TT, OMPMappableExprListClause<T> *C,
  llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec,
  DeclarationNameInfo &MapperIdInfo,
  llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) {
// Transform expressions in the list.
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return true;
  Vars.push_back(EVar.get());
}
// Transform mapper scope specifier and identifier.
NestedNameSpecifierLoc QualifierLoc;
if (C->getMapperQualifierLoc()) {
  QualifierLoc = TT.getDerived().TransformNestedNameSpecifierLoc(
      C->getMapperQualifierLoc());
  if (!QualifierLoc)
    return true;
}
MapperIdScopeSpec.Adopt(QualifierLoc);
MapperIdInfo = C->getMapperIdInfo();
if (MapperIdInfo.getName()) {
  MapperIdInfo = TT.getDerived().TransformDeclarationNameInfo(MapperIdInfo);
  if (!MapperIdInfo.getName())
    return true;
}
// Build a list of all candidate OMPDeclareMapperDecls, which is provided by
// the previous user-defined mapper lookup in dependent environment.
for (auto *E : C->mapperlists()) {
  // Transform all the decls.
  if (E) {
    auto *ULE = cast<UnresolvedLookupExpr>(E);
    UnresolvedSet<8> Decls;
    for (auto *D : ULE->decls()) {
      NamedDecl *InstD =
          cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D));
      Decls.addDecl(InstD, InstD->getAccess());
    }
    UnresolvedMappers.push_back(UnresolvedLookupExpr::Create(
        TT.getSema().Context, /*NamingClass=*/nullptr,
        MapperIdScopeSpec.getWithLocInContext(TT.getSema().Context),
        MapperIdInfo, /*ADL=*/true, ULE->isOverloaded(), Decls.begin(),
        Decls.end()));
  } else {
    UnresolvedMappers.push_back(nullptr);
  }
}
return false;
10372}

10374template <typename Derived>
10375OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
Expr *IteratorModifier = C->getIteratorModifier();
if (IteratorModifier) {
  ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
  if (MapModRes.isInvalid())
    return nullptr;
  IteratorModifier = MapModRes.get();
}
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPMapClause(
    IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(),
    MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(),
    C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10395}

10397template <typename Derived>
10398OMPClause *
10399TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) {
Expr *Allocator = C->getAllocator();
if (Allocator) {
  ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
  if (AllocatorRes.isInvalid())
    return nullptr;
  Allocator = AllocatorRes.get();
}
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPAllocateClause(
    Allocator, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
    C->getEndLoc());
10418}

10420template <typename Derived>
10421OMPClause *
10422TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTeams());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumTeamsClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10428}

10430template <typename Derived>
10431OMPClause *
10432TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPThreadLimitClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10438}

10440template <typename Derived>
10441OMPClause *
10442TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
ExprResult E = getDerived().TransformExpr(C->getPriority());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPPriorityClause(
    E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10448}

10450template <typename Derived>
10451OMPClause *
10452TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
ExprResult E = getDerived().TransformExpr(C->getGrainsize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPGrainsizeClause(
    C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getEndLoc());
10459}

10461template <typename Derived>
10462OMPClause *
10463TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
ExprResult E = getDerived().TransformExpr(C->getNumTasks());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPNumTasksClause(
    C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getModifierLoc(), C->getEndLoc());
10470}

10472template <typename Derived>
10473OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
ExprResult E = getDerived().TransformExpr(C->getHint());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(),
                                         C->getLParenLoc(), C->getEndLoc());
10479}

10481template <typename Derived>
10482OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
  OMPDistScheduleClause *C) {
ExprResult E = getDerived().TransformExpr(C->getChunkSize());
if (E.isInvalid())
  return nullptr;
return getDerived().RebuildOMPDistScheduleClause(
    C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
    C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
10490}

10492template <typename Derived>
10493OMPClause *
10494TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) {
// Rebuild Defaultmap Clause since we need to invoke the checking of
// defaultmap(none:variable-category) after template initialization.
return getDerived().RebuildOMPDefaultmapClause(C->getDefaultmapModifier(),
                                               C->getDefaultmapKind(),
                                               C->getBeginLoc(),
                                               C->getLParenLoc(),
                                               C->getDefaultmapModifierLoc(),
                                               C->getDefaultmapKindLoc(),
                                               C->getEndLoc());
10504}

10506template <typename Derived>
10507OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPToClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPToClause(
    C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
    MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10519}

10521template <typename Derived>
10522OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) {
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
llvm::SmallVector<Expr *, 16> Vars;
CXXScopeSpec MapperIdScopeSpec;
DeclarationNameInfo MapperIdInfo;
llvm::SmallVector<Expr *, 16> UnresolvedMappers;
if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
        *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
  return nullptr;
return getDerived().RebuildOMPFromClause(
    C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
    MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10534}

10536template <typename Derived>
10537OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
  OMPUseDevicePtrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPUseDevicePtrClause(Vars, Locs);
10549}

10551template <typename Derived>
10552OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause(
  OMPUseDeviceAddrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs);
10564}

10566template <typename Derived>
10567OMPClause *
10568TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
10579}

10581template <typename Derived>
10582OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause(
  OMPHasDeviceAddrClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs);
10594}

10596template <typename Derived>
10597OMPClause *
10598TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPNontemporalClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10609}

10611template <typename Derived>
10612OMPClause *
10613TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPInclusiveClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10624}

10626template <typename Derived>
10627OMPClause *
10628TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *C) {
llvm::SmallVector<Expr *, 16> Vars;
Vars.reserve(C->varlist_size());
for (auto *VE : C->varlists()) {
  ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
  if (EVar.isInvalid())
    return nullptr;
  Vars.push_back(EVar.get());
}
return getDerived().RebuildOMPExclusiveClause(
    Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10639}

10641template <typename Derived>
10642OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause(
  OMPUsesAllocatorsClause *C) {
SmallVector<Sema::UsesAllocatorsData, 16> Data;
Data.reserve(C->getNumberOfAllocators());
for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
  OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
  ExprResult Allocator = getDerived().TransformExpr(D.Allocator);
  if (Allocator.isInvalid())
    continue;
  ExprResult AllocatorTraits;
  if (Expr *AT = D.AllocatorTraits) {
    AllocatorTraits = getDerived().TransformExpr(AT);
    if (AllocatorTraits.isInvalid())
      continue;
  }
  Sema::UsesAllocatorsData &NewD = Data.emplace_back();
  NewD.Allocator = Allocator.get();
  NewD.AllocatorTraits = AllocatorTraits.get();
  NewD.LParenLoc = D.LParenLoc;
  NewD.RParenLoc = D.RParenLoc;
}
return getDerived().RebuildOMPUsesAllocatorsClause(
    Data, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10665}

10667template <typename Derived>
10668OMPClause *
10669TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) {
SmallVector<Expr *, 4> Locators;
Locators.reserve(C->varlist_size());
ExprResult ModifierRes;
if (Expr *Modifier = C->getModifier()) {
  ModifierRes = getDerived().TransformExpr(Modifier);
  if (ModifierRes.isInvalid())
    return nullptr;
}
for (Expr *E : C->varlists()) {
  ExprResult Locator = getDerived().TransformExpr(E);
  if (Locator.isInvalid())
    continue;
  Locators.push_back(Locator.get());
}
return getDerived().RebuildOMPAffinityClause(
    C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), C->getEndLoc(),
    ModifierRes.get(), Locators);
10687}

10689template <typename Derived>
10690OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) {
return getDerived().RebuildOMPOrderClause(
    C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(),
    C->getEndLoc(), C->getModifier(), C->getModifierKwLoc());
10694}

10696template <typename Derived>
10697OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *C) {
return getDerived().RebuildOMPBindClause(
    C->getBindKind(), C->getBindKindLoc(), C->getBeginLoc(),
    C->getLParenLoc(), C->getEndLoc());
10701}

10703template <typename Derived>
10704OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause(
  OMPXDynCGroupMemClause *C) {
ExprResult Size = getDerived().TransformExpr(C->getSize());
if (Size.isInvalid())
  return nullptr;
return getDerived().RebuildOMPXDynCGroupMemClause(
    Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10711}

10713//===----------------------------------------------------------------------===//
10714// Expression transformation
10715//===----------------------------------------------------------------------===//
10716template<typename Derived>
10717ExprResult
10718TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *E) {
return TransformExpr(E->getSubExpr());
10720}

10722template <typename Derived>
10723ExprResult TreeTransform<Derived>::TransformSYCLUniqueStableNameExpr(
  SYCLUniqueStableNameExpr *E) {
if (!E->isTypeDependent())
  return E;

TypeSourceInfo *NewT = getDerived().TransformType(E->getTypeSourceInfo());

if (!NewT)
  return ExprError();

if (!getDerived().AlwaysRebuild() && E->getTypeSourceInfo() == NewT)
  return E;

return getDerived().RebuildSYCLUniqueStableNameExpr(
    E->getLocation(), E->getLParenLocation(), E->getRParenLocation(), NewT);
10738}

10740template<typename Derived>
10741ExprResult
10742TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
if (!E->isTypeDependent())
  return E;

return getDerived().RebuildPredefinedExpr(E->getLocation(),
                                          E->getIdentKind());
10748}

10750template<typename Derived>
10751ExprResult
10752TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifierLoc()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

ValueDecl *ND
  = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
                                                       E->getDecl()));
if (!ND)
  return ExprError();

NamedDecl *Found = ND;
if (E->getFoundDecl() != E->getDecl()) {
  Found = cast_or_null<NamedDecl>(
      getDerived().TransformDecl(E->getLocation(), E->getFoundDecl()));
  if (!Found)
    return ExprError();
}

DeclarationNameInfo NameInfo = E->getNameInfo();
if (NameInfo.getName()) {
  NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
  if (!NameInfo.getName())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    QualifierLoc == E->getQualifierLoc() &&
    ND == E->getDecl() &&
    Found == E->getFoundDecl() &&
    NameInfo.getName() == E->getDecl()->getDeclName() &&
    !E->hasExplicitTemplateArgs()) {

  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  SemaRef.MarkDeclRefReferenced(E);

  return E;
}

TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
if (E->hasExplicitTemplateArgs()) {
  TemplateArgs = &TransArgs;
  TransArgs.setLAngleLoc(E->getLAngleLoc());
  TransArgs.setRAngleLoc(E->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                              E->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
                                       Found, TemplateArgs);
10809}

10811template<typename Derived>
10812ExprResult
10813TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
return E;
10815}

10817template <typename Derived>
10818ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
  FixedPointLiteral *E) {
return E;
10821}

10823template<typename Derived>
10824ExprResult
10825TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
return E;
10827}

10829template<typename Derived>
10830ExprResult
10831TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
return E;
10833}

10835template<typename Derived>
10836ExprResult
10837TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
return E;
10839}

10841template<typename Derived>
10842ExprResult
10843TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
return E;
10845}

10847template<typename Derived>
10848ExprResult
10849TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
return getDerived().TransformCallExpr(E);
10851}

10853template<typename Derived>
10854ExprResult
10855TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
ExprResult ControllingExpr =
  getDerived().TransformExpr(E->getControllingExpr());
if (ControllingExpr.isInvalid())
  return ExprError();

SmallVector<Expr *, 4> AssocExprs;
SmallVector<TypeSourceInfo *, 4> AssocTypes;
for (const GenericSelectionExpr::Association Assoc : E->associations()) {
  TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
  if (TSI) {
    TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
    if (!AssocType)
      return ExprError();
    AssocTypes.push_back(AssocType);
  } else {
    AssocTypes.push_back(nullptr);
  }

  ExprResult AssocExpr =
      getDerived().TransformExpr(Assoc.getAssociationExpr());
  if (AssocExpr.isInvalid())
    return ExprError();
  AssocExprs.push_back(AssocExpr.get());
}

return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
                                                E->getDefaultLoc(),
                                                E->getRParenLoc(),
                                                ControllingExpr.get(),
                                                AssocTypes,
                                                AssocExprs);
10887}

10889template<typename Derived>
10890ExprResult
10891TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
                                     E->getRParen());
10901}

10903/// The operand of a unary address-of operator has special rules: it's
10904/// allowed to refer to a non-static member of a class even if there's no 'this'
10905/// object available.
10906template<typename Derived>
10907ExprResult
10908TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E))
  return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr);
else
  return getDerived().TransformExpr(E);
10913}

10915template<typename Derived>
10916ExprResult
10917TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
ExprResult SubExpr;
if (E->getOpcode() == UO_AddrOf)
  SubExpr = TransformAddressOfOperand(E->getSubExpr());
else
  SubExpr = TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
                                         E->getOpcode(),
                                         SubExpr.get());
10932}

10934template<typename Derived>
10935ExprResult
10936TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
// Transform the type.
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
if (!Type)
  return ExprError();

// Transform all of the components into components similar to what the
// parser uses.
// FIXME: It would be slightly more efficient in the non-dependent case to
// just map FieldDecls, rather than requiring the rebuilder to look for
// the fields again. However, __builtin_offsetof is rare enough in
// template code that we don't care.
bool ExprChanged = false;
typedef Sema::OffsetOfComponent Component;
SmallVector<Component, 4> Components;
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
  const OffsetOfNode &ON = E->getComponent(I);
  Component Comp;
  Comp.isBrackets = true;
  Comp.LocStart = ON.getSourceRange().getBegin();
  Comp.LocEnd = ON.getSourceRange().getEnd();
  switch (ON.getKind()) {
  case OffsetOfNode::Array: {
    Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
    ExprResult Index = getDerived().TransformExpr(FromIndex);
    if (Index.isInvalid())
      return ExprError();

    ExprChanged = ExprChanged || Index.get() != FromIndex;
    Comp.isBrackets = true;
    Comp.U.E = Index.get();
    break;
  }

  case OffsetOfNode::Field:
  case OffsetOfNode::Identifier:
    Comp.isBrackets = false;
    Comp.U.IdentInfo = ON.getFieldName();
    if (!Comp.U.IdentInfo)
      continue;

    break;

  case OffsetOfNode::Base:
    // Will be recomputed during the rebuild.
    continue;
  }

  Components.push_back(Comp);
}

// If nothing changed, retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeSourceInfo() &&
    !ExprChanged)
  return E;

// Build a new offsetof expression.
return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
                                        Components, E->getRParenLoc());
10996}

10998template<typename Derived>
10999ExprResult
11000TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&(static_cast <bool> ((!E->getSourceExpr() || getDerived
().AlreadyTransformed(E->getType())) && "opaque value expression requires transformation"
) ? void (0) : __assert_fail ("(!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && \"opaque value expression requires transformation\""
, "clang/lib/Sema/TreeTransform.h", 11002, __extension__ __PRETTY_FUNCTION__
))
       "opaque value expression requires transformation")(static_cast <bool> ((!E->getSourceExpr() || getDerived
().AlreadyTransformed(E->getType())) && "opaque value expression requires transformation"
) ? void (0) : __assert_fail ("(!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) && \"opaque value expression requires transformation\""
, "clang/lib/Sema/TreeTransform.h", 11002, __extension__ __PRETTY_FUNCTION__
));
return E;
11004}

11006template<typename Derived>
11007ExprResult
11008TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
return E;
11010}

11012template <typename Derived>
11013ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *E) {
llvm::SmallVector<Expr *, 8> Children;
bool Changed = false;
for (Expr *C : E->subExpressions()) {
  ExprResult NewC = getDerived().TransformExpr(C);
  if (NewC.isInvalid())
    return ExprError();
  Children.push_back(NewC.get());

  Changed |= NewC.get() != C;
}
if (!getDerived().AlwaysRebuild() && !Changed)
  return E;
return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(),
                                        Children, E->getType());
11028}

11030template<typename Derived>
11031ExprResult
11032TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
// Rebuild the syntactic form.  The original syntactic form has
// opaque-value expressions in it, so strip those away and rebuild
// the result.  This is a really awful way of doing this, but the
// better solution (rebuilding the semantic expressions and
// rebinding OVEs as necessary) doesn't work; we'd need
// TreeTransform to not strip away implicit conversions.
Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
ExprResult result = getDerived().TransformExpr(newSyntacticForm);
if (result.isInvalid()) return ExprError();

// If that gives us a pseudo-object result back, the pseudo-object
// expression must have been an lvalue-to-rvalue conversion which we
// should reapply.
if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
  result = SemaRef.checkPseudoObjectRValue(result.get());

return result;
11050}

11052template<typename Derived>
11053ExprResult
11054TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
                                              UnaryExprOrTypeTraitExpr *E) {
if (E->isArgumentType()) {
  TypeSourceInfo *OldT = E->getArgumentTypeInfo();

  TypeSourceInfo *NewT = getDerived().TransformType(OldT);
  if (!NewT)
    return ExprError();

  if (!getDerived().AlwaysRebuild() && OldT == NewT)
    return E;

  return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
                                                  E->getKind(),
                                                  E->getSourceRange());
}

// C++0x [expr.sizeof]p1:
//   The operand is either an expression, which is an unevaluated operand
//   [...]
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

// Try to recover if we have something like sizeof(T::X) where X is a type.
// Notably, there must be *exactly* one set of parens if X is a type.
TypeSourceInfo *RecoveryTSI = nullptr;
ExprResult SubExpr;
auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
if (auto *DRE =
        PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
  SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
      PE, DRE, false, &RecoveryTSI);
else
  SubExpr = getDerived().TransformExpr(E->getArgumentExpr());

if (RecoveryTSI) {
  return getDerived().RebuildUnaryExprOrTypeTrait(
      RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
} else if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
  return E;

return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
                                                E->getOperatorLoc(),
                                                E->getKind(),
                                                E->getSourceRange());
11103}

11105template<typename Derived>
11106ExprResult
11107TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();


if (!getDerived().AlwaysRebuild() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildArraySubscriptExpr(
    LHS.get(),
    /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
11125}

11127template <typename Derived>
11128ExprResult
11129TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx());
if (RowIdx.isInvalid())
  return ExprError();

ExprResult ColumnIdx = getDerived().TransformExpr(E->getColumnIdx());
if (ColumnIdx.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
    RowIdx.get() == E->getRowIdx() && ColumnIdx.get() == E->getColumnIdx())
  return E;

return getDerived().RebuildMatrixSubscriptExpr(
    Base.get(), RowIdx.get(), ColumnIdx.get(), E->getRBracketLoc());
11148}

11150template <typename Derived>
11151ExprResult
11152TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ExprResult LowerBound;
if (E->getLowerBound()) {
  LowerBound = getDerived().TransformExpr(E->getLowerBound());
  if (LowerBound.isInvalid())
    return ExprError();
}

ExprResult Length;
if (E->getLength()) {
  Length = getDerived().TransformExpr(E->getLength());
  if (Length.isInvalid())
    return ExprError();
}

ExprResult Stride;
if (Expr *Str = E->getStride()) {
  Stride = getDerived().TransformExpr(Str);
  if (Stride.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
    LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
  return E;

return getDerived().RebuildOMPArraySectionExpr(
    Base.get(), E->getBase()->getEndLoc(), LowerBound.get(),
    E->getColonLocFirst(), E->getColonLocSecond(), Length.get(), Stride.get(),
    E->getRBracketLoc());
11186}

11188template <typename Derived>
11189ExprResult
11190TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

SmallVector<Expr *, 4> Dims;
bool ErrorFound = false;
for (Expr *Dim : E->getDimensions()) {
  ExprResult DimRes = getDerived().TransformExpr(Dim);
  if (DimRes.isInvalid()) {
    ErrorFound = true;
    continue;
  }
  Dims.push_back(DimRes.get());
}

if (ErrorFound)
  return ExprError();
return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(),
                                               E->getRParenLoc(), Dims,
                                               E->getBracketsRanges());
11211}

11213template <typename Derived>
11214ExprResult
11215TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *E) {
unsigned NumIterators = E->numOfIterators();
SmallVector<Sema::OMPIteratorData, 4> Data(NumIterators);

bool ErrorFound = false;
bool NeedToRebuild = getDerived().AlwaysRebuild();
for (unsigned I = 0; I < NumIterators; ++I) {
  auto *D = cast<VarDecl>(E->getIteratorDecl(I));
  Data[I].DeclIdent = D->getIdentifier();
  Data[I].DeclIdentLoc = D->getLocation();
  if (D->getLocation() == D->getBeginLoc()) {
    assert(SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) &&(static_cast <bool> (SemaRef.Context.hasSameType(D->
getType(), SemaRef.Context.IntTy) && "Implicit type must be int."
) ? void (0) : __assert_fail ("SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) && \"Implicit type must be int.\""
, "clang/lib/Sema/TreeTransform.h", 11227, __extension__ __PRETTY_FUNCTION__
))
           "Implicit type must be int.")(static_cast <bool> (SemaRef.Context.hasSameType(D->
getType(), SemaRef.Context.IntTy) && "Implicit type must be int."
) ? void (0) : __assert_fail ("SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) && \"Implicit type must be int.\""
, "clang/lib/Sema/TreeTransform.h", 11227, __extension__ __PRETTY_FUNCTION__
));
  } else {
    TypeSourceInfo *TSI = getDerived().TransformType(D->getTypeSourceInfo());
    QualType DeclTy = getDerived().TransformType(D->getType());
    Data[I].Type = SemaRef.CreateParsedType(DeclTy, TSI);
  }
  OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
  ExprResult Begin = getDerived().TransformExpr(Range.Begin);
  ExprResult End = getDerived().TransformExpr(Range.End);
  ExprResult Step = getDerived().TransformExpr(Range.Step);
  ErrorFound = ErrorFound ||
               !(!D->getTypeSourceInfo() || (Data[I].Type.getAsOpaquePtr() &&
                                             !Data[I].Type.get().isNull())) ||
               Begin.isInvalid() || End.isInvalid() || Step.isInvalid();
  if (ErrorFound)
    continue;
  Data[I].Range.Begin = Begin.get();
  Data[I].Range.End = End.get();
  Data[I].Range.Step = Step.get();
  Data[I].AssignLoc = E->getAssignLoc(I);
  Data[I].ColonLoc = E->getColonLoc(I);
  Data[I].SecColonLoc = E->getSecondColonLoc(I);
  NeedToRebuild =
      NeedToRebuild ||
      (D->getTypeSourceInfo() && Data[I].Type.get().getTypePtrOrNull() !=
                                     D->getType().getTypePtrOrNull()) ||
      Range.Begin != Data[I].Range.Begin || Range.End != Data[I].Range.End ||
      Range.Step != Data[I].Range.Step;
}
if (ErrorFound)
  return ExprError();
if (!NeedToRebuild)
  return E;

ExprResult Res = getDerived().RebuildOMPIteratorExpr(
    E->getIteratorKwLoc(), E->getLParenLoc(), E->getRParenLoc(), Data);
if (!Res.isUsable())
  return Res;
auto *IE = cast<OMPIteratorExpr>(Res.get());
for (unsigned I = 0; I < NumIterators; ++I)
  getDerived().transformedLocalDecl(E->getIteratorDecl(I),
                                    IE->getIteratorDecl(I));
return Res;
11270}

11272template<typename Derived>
11273ExprResult
11274TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
  = ((Expr *)Callee.get())->getSourceRange().getBegin();

Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
if (E->hasStoredFPFeatures()) {
  FPOptionsOverride NewOverrides = E->getFPFeatures();
  getSema().CurFPFeatures =
      NewOverrides.applyOverrides(getSema().getLangOpts());
  getSema().FpPragmaStack.CurrentValue = NewOverrides;
}

return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                    Args,
                                    E->getRParenLoc());
11307}

11309template<typename Derived>
11310ExprResult
11311TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

NestedNameSpecifierLoc QualifierLoc;
if (E->hasQualifier()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());

  if (!QualifierLoc)
    return ExprError();
}
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

ValueDecl *Member
  = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
                                                       E->getMemberDecl()));
if (!Member)
  return ExprError();

NamedDecl *FoundDecl = E->getFoundDecl();
if (FoundDecl == E->getMemberDecl()) {
  FoundDecl = Member;
} else {
  FoundDecl = cast_or_null<NamedDecl>(
                 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
  if (!FoundDecl)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase() &&
    QualifierLoc == E->getQualifierLoc() &&
    Member == E->getMemberDecl() &&
    FoundDecl == E->getFoundDecl() &&
    !E->hasExplicitTemplateArgs()) {

  // Skip for member expression of (this->f), rebuilt thisi->f is needed
  // for Openmp where the field need to be privatizized in the case.
  if (!(isa<CXXThisExpr>(E->getBase()) &&
        getSema().isOpenMPRebuildMemberExpr(cast<ValueDecl>(Member)))) {
    // Mark it referenced in the new context regardless.
    // FIXME: this is a bit instantiation-specific.
    SemaRef.MarkMemberReferenced(E);
    return E;
  }
}

TemplateArgumentListInfo TransArgs;
if (E->hasExplicitTemplateArgs()) {
  TransArgs.setLAngleLoc(E->getLAngleLoc());
  TransArgs.setRAngleLoc(E->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                              E->getNumTemplateArgs(),
                                              TransArgs))
    return ExprError();
}

// FIXME: Bogus source location for the operator
SourceLocation FakeOperatorLoc =
    SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());

// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;
DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
if (MemberNameInfo.getName()) {
  MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
  if (!MemberNameInfo.getName())
    return ExprError();
}

return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
                                      E->isArrow(),
                                      QualifierLoc,
                                      TemplateKWLoc,
                                      MemberNameInfo,
                                      Member,
                                      FoundDecl,
                                      (E->hasExplicitTemplateArgs()
                                         ? &TransArgs : nullptr),
                                      FirstQualifierInScope);
11396}

11398template<typename Derived>
11399ExprResult
11400TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

if (E->isCompoundAssignmentOp())
  // FPFeatures has already been established from trailing storage
  return getDerived().RebuildBinaryOperator(
      E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get());
Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
FPOptionsOverride NewOverrides(E->getFPFeatures());
getSema().CurFPFeatures =
    NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;
return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
                                          LHS.get(), RHS.get());
11425}

11427template <typename Derived>
11428ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
  CXXRewrittenBinaryOperator *E) {
CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm();

ExprResult LHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.LHS));
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.RHS));
if (RHS.isInvalid())
  return ExprError();

// Extract the already-resolved callee declarations so that we can restrict
// ourselves to using them as the unqualified lookup results when rebuilding.
UnresolvedSet<2> UnqualLookups;
bool ChangedAnyLookups = false;
Expr *PossibleBinOps[] = {E->getSemanticForm(),
                          const_cast<Expr *>(Decomp.InnerBinOp)};
for (Expr *PossibleBinOp : PossibleBinOps) {
  auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit());
  if (!Op)
    continue;
  auto *Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit());
  if (!Callee || isa<CXXMethodDecl>(Callee->getDecl()))
    continue;

  // Transform the callee in case we built a call to a local extern
  // declaration.
  NamedDecl *Found = cast_or_null<NamedDecl>(getDerived().TransformDecl(
      E->getOperatorLoc(), Callee->getFoundDecl()));
  if (!Found)
    return ExprError();
  if (Found != Callee->getFoundDecl())
    ChangedAnyLookups = true;
  UnqualLookups.addDecl(Found);
}

if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups &&
    LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) {
  // Mark all functions used in the rewrite as referenced. Note that when
  // a < b is rewritten to (a <=> b) < 0, both the <=> and the < might be
  // function calls, and/or there might be a user-defined conversion sequence
  // applied to the operands of the <.
  // FIXME: this is a bit instantiation-specific.
  const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS};
  SemaRef.MarkDeclarationsReferencedInExpr(E, false, StopAt);
  return E;
}

return getDerived().RebuildCXXRewrittenBinaryOperator(
    E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
11479}

11481template<typename Derived>
11482ExprResult
11483TreeTransform<Derived>::TransformCompoundAssignOperator(
                                                    CompoundAssignOperator *E) {
Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
FPOptionsOverride NewOverrides(E->getFPFeatures());
getSema().CurFPFeatures =
    NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;
return getDerived().TransformBinaryOperator(E);
11491}

11493template<typename Derived>
11494ExprResult TreeTransform<Derived>::
11495TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
// Just rebuild the common and RHS expressions and see whether we
// get any changes.

ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
if (commonExpr.isInvalid())
  return ExprError();

ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
if (rhs.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    commonExpr.get() == e->getCommon() &&
    rhs.get() == e->getFalseExpr())
  return e;

return getDerived().RebuildConditionalOperator(commonExpr.get(),
                                               e->getQuestionLoc(),
                                               nullptr,
                                               e->getColonLoc(),
                                               rhs.get());
11517}

11519template<typename Derived>
11520ExprResult
11521TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
  return ExprError();

ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == E->getCond() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildConditionalOperator(Cond.get(),
                                               E->getQuestionLoc(),
                                               LHS.get(),
                                               E->getColonLoc(),
                                               RHS.get());
11545}

11547template<typename Derived>
11548ExprResult
11549TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
// Implicit casts are eliminated during transformation, since they
// will be recomputed by semantic analysis after transformation.
return getDerived().TransformExpr(E->getSubExprAsWritten());
11553}

11555template<typename Derived>
11556ExprResult
11557TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
                                          Type,
                                          E->getRParenLoc(),
                                          SubExpr.get());
11576}

11578template<typename Derived>
11579ExprResult
11580TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
TypeSourceInfo *OldT = E->getTypeSourceInfo();
TypeSourceInfo *NewT = getDerived().TransformType(OldT);
if (!NewT)
  return ExprError();

ExprResult Init = getDerived().TransformExpr(E->getInitializer());
if (Init.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    OldT == NewT &&
    Init.get() == E->getInitializer())
  return SemaRef.MaybeBindToTemporary(E);

// Note: the expression type doesn't necessarily match the
// type-as-written, but that's okay, because it should always be
// derivable from the initializer.

return getDerived().RebuildCompoundLiteralExpr(
    E->getLParenLoc(), NewT,
    /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get());
11602}

11604template<typename Derived>
11605ExprResult
11606TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

// FIXME: Bad source location
SourceLocation FakeOperatorLoc =
    SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc());
return getDerived().RebuildExtVectorElementExpr(
    Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(),
    E->getAccessor());
11621}

11623template<typename Derived>
11624ExprResult
11625TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
if (InitListExpr *Syntactic = E->getSyntacticForm())
  E = Syntactic;

bool InitChanged = false;

EnterExpressionEvaluationContext Context(
    getSema(), EnterExpressionEvaluationContext::InitList);

SmallVector<Expr*, 4> Inits;
if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
                                Inits, &InitChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() && !InitChanged) {
  // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
  // in some cases. We can't reuse it in general, because the syntactic and
  // semantic forms are linked, and we can't know that semantic form will
  // match even if the syntactic form does.
}

return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
                                    E->getRBraceLoc());
11648}

11650template<typename Derived>
11651ExprResult
11652TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
Designation Desig;

// transform the initializer value
ExprResult Init = getDerived().TransformExpr(E->getInit());
if (Init.isInvalid())
  return ExprError();

// transform the designators.
SmallVector<Expr*, 4> ArrayExprs;
bool ExprChanged = false;
for (const DesignatedInitExpr::Designator &D : E->designators()) {
  if (D.isFieldDesignator()) {
    Desig.AddDesignator(Designator::CreateFieldDesignator(
        D.getFieldName(), D.getDotLoc(), D.getFieldLoc()));
    if (D.getFieldDecl()) {
      FieldDecl *Field = cast_or_null<FieldDecl>(
          getDerived().TransformDecl(D.getFieldLoc(), D.getFieldDecl()));
      if (Field != D.getFieldDecl())
        // Rebuild the expression when the transformed FieldDecl is
        // different to the already assigned FieldDecl.
        ExprChanged = true;
    } else {
      // Ensure that the designator expression is rebuilt when there isn't
      // a resolved FieldDecl in the designator as we don't want to assign
      // a FieldDecl to a pattern designator that will be instantiated again.
      ExprChanged = true;
    }
    continue;
  }

  if (D.isArrayDesignator()) {
    ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
    if (Index.isInvalid())
      return ExprError();

    Desig.AddDesignator(
        Designator::CreateArrayDesignator(Index.get(), D.getLBracketLoc()));

    ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
    ArrayExprs.push_back(Index.get());
    continue;
  }

  assert(D.isArrayRangeDesignator() && "New kind of designator?")(static_cast <bool> (D.isArrayRangeDesignator() &&
 "New kind of designator?") ? void (0) : __assert_fail ("D.isArrayRangeDesignator() && \"New kind of designator?\""
, "clang/lib/Sema/TreeTransform.h", 11696, __extension__ __PRETTY_FUNCTION__
));
  ExprResult Start
    = getDerived().TransformExpr(E->getArrayRangeStart(D));
  if (Start.isInvalid())
    return ExprError();

  ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
  if (End.isInvalid())
    return ExprError();

  Desig.AddDesignator(Designator::CreateArrayRangeDesignator(
      Start.get(), End.get(), D.getLBracketLoc(), D.getEllipsisLoc()));

  ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
                End.get() != E->getArrayRangeEnd(D);

  ArrayExprs.push_back(Start.get());
  ArrayExprs.push_back(End.get());
}

if (!getDerived().AlwaysRebuild() &&
    Init.get() == E->getInit() &&
    !ExprChanged)
  return E;

return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
                                              E->getEqualOrColonLoc(),
                                              E->usesGNUSyntax(), Init.get());
11724}

11726// Seems that if TransformInitListExpr() only works on the syntactic form of an
11727// InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
11728template<typename Derived>
11729ExprResult
11730TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
  DesignatedInitUpdateExpr *E) {
llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "::llvm::llvm_unreachable_internal("Unexpected DesignatedInitUpdateExpr in syntactic form of "
 "initializer", "clang/lib/Sema/TreeTransform.h", 11733)
                 "initializer")::llvm::llvm_unreachable_internal("Unexpected DesignatedInitUpdateExpr in syntactic form of "
 "initializer", "clang/lib/Sema/TreeTransform.h", 11733);
return ExprError();
11735}

11737template<typename Derived>
11738ExprResult
11739TreeTransform<Derived>::TransformNoInitExpr(
  NoInitExpr *E) {
llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer")::llvm::llvm_unreachable_internal("Unexpected NoInitExpr in syntactic form of initializer"
, "clang/lib/Sema/TreeTransform.h", 11741);
return ExprError();
11743}

11745template<typename Derived>
11746ExprResult
11747TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer")::llvm::llvm_unreachable_internal("Unexpected ArrayInitLoopExpr outside of initializer"
, "clang/lib/Sema/TreeTransform.h", 11748);
return ExprError();
11750}

11752template<typename Derived>
11753ExprResult
11754TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer")::llvm::llvm_unreachable_internal("Unexpected ArrayInitIndexExpr outside of initializer"
, "clang/lib/Sema/TreeTransform.h", 11755);
return ExprError();
11757}

11759template<typename Derived>
11760ExprResult
11761TreeTransform<Derived>::TransformImplicitValueInitExpr(
                                                   ImplicitValueInitExpr *E) {
TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName());

// FIXME: Will we ever have proper type location here? Will we actually
// need to transform the type?
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getType())
  return E;

return getDerived().RebuildImplicitValueInitExpr(T);
11776}

11778template<typename Derived>
11779ExprResult
11780TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
if (!TInfo)
  return ExprError();

ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    TInfo == E->getWrittenTypeInfo() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
                                     TInfo, E->getRParenLoc());
11796}

11798template<typename Derived>
11799ExprResult
11800TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 4> Inits;
if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
                   &ArgumentChanged))
  return ExprError();

return getDerived().RebuildParenListExpr(E->getLParenLoc(),
                                         Inits,
                                         E->getRParenLoc());
11810}

11812/// Transform an address-of-label expression.
11813///
11814/// By default, the transformation of an address-of-label expression always
11815/// rebuilds the expression, so that the label identifier can be resolved to
11816/// the corresponding label statement by semantic analysis.
11817template<typename Derived>
11818ExprResult
11819TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
                                      E->getLabel());
if (!LD)
  return ExprError();

return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
                                         cast<LabelDecl>(LD));
11827}

11829template<typename Derived>
11830ExprResult
11831TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
SemaRef.ActOnStartStmtExpr();
StmtResult SubStmt
  = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
if (SubStmt.isInvalid()) {
  SemaRef.ActOnStmtExprError();
  return ExprError();
}

unsigned OldDepth = E->getTemplateDepth();
unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);

if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
    SubStmt.get() == E->getSubStmt()) {
  // Calling this an 'error' is unintuitive, but it does the right thing.
  SemaRef.ActOnStmtExprError();
  return SemaRef.MaybeBindToTemporary(E);
}

return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(),
                                    E->getRParenLoc(), NewDepth);
11852}

11854template<typename Derived>
11855ExprResult
11856TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
ExprResult Cond = getDerived().TransformExpr(E->getCond());
if (Cond.isInvalid())
  return ExprError();

ExprResult LHS = getDerived().TransformExpr(E->getLHS());
if (LHS.isInvalid())
  return ExprError();

ExprResult RHS = getDerived().TransformExpr(E->getRHS());
if (RHS.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Cond.get() == E->getCond() &&
    LHS.get() == E->getLHS() &&
    RHS.get() == E->getRHS())
  return E;

return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
                                      Cond.get(), LHS.get(), RHS.get(),
                                      E->getRParenLoc());
11878}

11880template<typename Derived>
11881ExprResult
11882TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
return E;
11884}

11886template<typename Derived>
11887ExprResult
11888TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
switch (E->getOperator()) {
3
←
Control jumps to 'case OO_Subscript:'  at line 11896→
case OO_New:
case OO_Delete:
case OO_Array_New:
case OO_Array_Delete:
  llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr")::llvm::llvm_unreachable_internal("new and delete operators cannot use CXXOperatorCallExpr"
, "clang/lib/Sema/TreeTransform.h", 11894);

case OO_Subscript:
case OO_Call: {
  // This is a call to an object's operator().
  assert(E->getNumArgs() >= 1 && "Object call is missing arguments")(static_cast <bool> (E->getNumArgs() >= 1 &&
 "Object call is missing arguments") ? void (0) : __assert_fail
 ("E->getNumArgs() >= 1 && \"Object call is missing arguments\""
, "clang/lib/Sema/TreeTransform.h", 11899, __extension__ __PRETTY_FUNCTION__
));
4
←
Assuming the condition is true→
5
←
'?' condition is true→

  // Transform the object itself.
  ExprResult Object = getDerived().TransformExpr(E->getArg(0));
  if (Object.isInvalid())
6
←
Assuming the condition is false→
7
←
Taking false branch→
    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,
8
←
Taking false branch→
                                  Args))
    return ExprError();

  if (E->getOperator() == OO_Subscript)
9
←
Taking true branch→
    return getDerived().RebuildCxxSubscriptExpr(Object.get(), FakeLParenLoc,
10
←
Calling 'ActionResult::get'→
14
←
Returning from 'ActionResult::get'→
15
←
Passing value via 1st parameter 'Callee'→
16
←
Calling 'TreeTransform::RebuildCxxSubscriptExpr'→
                                                Args, E->getEndLoc());

  return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args,
                                      E->getEndLoc());
}

11924#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)  \
case OO_##Name:                                                              \
  break;

11928#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
11929#include "clang/Basic/OperatorKinds.def"

case OO_Conditional:
  llvm_unreachable("conditional operator is not actually overloadable")::llvm::llvm_unreachable_internal("conditional operator is not actually overloadable"
, "clang/lib/Sema/TreeTransform.h", 11932);

case OO_None:
case NUM_OVERLOADED_OPERATORS:
  llvm_unreachable("not an overloaded operator?")::llvm::llvm_unreachable_internal("not an overloaded operator?"
, "clang/lib/Sema/TreeTransform.h", 11936);
}

ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

ExprResult First;
if (E->getOperator() == OO_Amp)
  First = getDerived().TransformAddressOfOperand(E->getArg(0));
else
  First = getDerived().TransformExpr(E->getArg(0));
if (First.isInvalid())
  return ExprError();

ExprResult Second;
if (E->getNumArgs() == 2) {
  Second = getDerived().TransformExpr(E->getArg(1));
  if (Second.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    First.get() == E->getArg(0) &&
    (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
  return SemaRef.MaybeBindToTemporary(E);

Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
FPOptionsOverride NewOverrides(E->getFPFeatures());
getSema().CurFPFeatures =
    NewOverrides.applyOverrides(getSema().getLangOpts());
getSema().FpPragmaStack.CurrentValue = NewOverrides;

return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
                                               E->getOperatorLoc(),
                                               Callee.get(),
                                               First.get(),
                                               Second.get());
11975}

11977template<typename Derived>
11978ExprResult
11979TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
return getDerived().TransformCallExpr(E);
11981}

11983template <typename Derived>
11984ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
bool NeedRebuildFunc = E->getIdentKind() == SourceLocExpr::Function &&
                       getSema().CurContext != E->getParentContext();

if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
  return E;

return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getType(),
                                         E->getBeginLoc(), E->getEndLoc(),
                                         getSema().CurContext);
11994}

11996template<typename Derived>
11997ExprResult
11998TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
// Transform the callee.
ExprResult Callee = getDerived().TransformExpr(E->getCallee());
if (Callee.isInvalid())
  return ExprError();

// Transform exec config.
ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
if (EC.isInvalid())
  return ExprError();

// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Callee.get() == E->getCallee() &&
    !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// FIXME: Wrong source location information for the '('.
SourceLocation FakeLParenLoc
  = ((Expr *)Callee.get())->getSourceRange().getBegin();
return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                    Args,
                                    E->getRParenLoc(), EC.get());
12027}

12029template<typename Derived>
12030ExprResult
12031TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;
return getDerived().RebuildCXXNamedCastExpr(
    E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
    Type, E->getAngleBrackets().getEnd(),
    // FIXME. this should be '(' location
    E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
12050}

12052template<typename Derived>
12053ExprResult
12054TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
TypeSourceInfo *TSI =
    getDerived().TransformType(BCE->getTypeInfoAsWritten());
if (!TSI)
  return ExprError();

ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
if (Sub.isInvalid())
  return ExprError();

return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
                                              Sub.get(), BCE->getEndLoc());
12066}

12068template<typename Derived>
12069ExprResult
12070TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12072}

12074template<typename Derived>
12075ExprResult
12076TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12078}

12080template<typename Derived>
12081ExprResult
12082TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
                                                    CXXReinterpretCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12085}

12087template<typename Derived>
12088ExprResult
12089TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12091}

12093template<typename Derived>
12094ExprResult
12095TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
return getDerived().TransformCXXNamedCastExpr(E);
12097}

12099template<typename Derived>
12100ExprResult
12101TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
                                                   CXXFunctionalCastExpr *E) {
TypeSourceInfo *Type =
    getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
if (!Type)
  return ExprError();

ExprResult SubExpr
  = getDerived().TransformExpr(E->getSubExprAsWritten());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeInfoAsWritten() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCXXFunctionalCastExpr(Type,
                                                 E->getLParenLoc(),
                                                 SubExpr.get(),
                                                 E->getRParenLoc(),
                                                 E->isListInitialization());
12123}

12125template<typename Derived>
12126ExprResult
12127TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
if (E->isTypeOperand()) {
  TypeSourceInfo *TInfo
    = getDerived().TransformType(E->getTypeOperandSourceInfo());
  if (!TInfo)
    return ExprError();

  if (!getDerived().AlwaysRebuild() &&
      TInfo == E->getTypeOperandSourceInfo())
    return E;

  return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
                                           TInfo, E->getEndLoc());
}

// Typeid's operand is an unevaluated context, unless it's a polymorphic
// type.  We must not unilaterally enter unevaluated context here, as then
// semantic processing can re-transform an already transformed operand.
Expr *Op = E->getExprOperand();
auto EvalCtx = Sema::ExpressionEvaluationContext::Unevaluated;
if (E->isGLValue())
  if (auto *RecordT = Op->getType()->getAs<RecordType>())
    if (cast<CXXRecordDecl>(RecordT->getDecl())->isPolymorphic())
      EvalCtx = SemaRef.ExprEvalContexts.back().Context;

EnterExpressionEvaluationContext Unevaluated(SemaRef, EvalCtx,
                                             Sema::ReuseLambdaContextDecl);

ExprResult SubExpr = getDerived().TransformExpr(Op);
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getExprOperand())
  return E;

return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
                                         SubExpr.get(), E->getEndLoc());
12165}

12167template<typename Derived>
12168ExprResult
12169TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
if (E->isTypeOperand()) {
  TypeSourceInfo *TInfo
    = getDerived().TransformType(E->getTypeOperandSourceInfo());
  if (!TInfo)
    return ExprError();

  if (!getDerived().AlwaysRebuild() &&
      TInfo == E->getTypeOperandSourceInfo())
    return E;

  return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
                                           TInfo, E->getEndLoc());
}

EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);

ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getExprOperand())
  return E;

return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
                                         SubExpr.get(), E->getEndLoc());
12197}

12199template<typename Derived>
12200ExprResult
12201TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
return E;
12203}

12205template<typename Derived>
12206ExprResult
12207TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
                                                   CXXNullPtrLiteralExpr *E) {
return E;
12210}

12212template<typename Derived>
12213ExprResult
12214TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
QualType T = getSema().getCurrentThisType();

if (!getDerived().AlwaysRebuild() && T == E->getType()) {
  // Mark it referenced in the new context regardless.
  // FIXME: this is a bit instantiation-specific.
  getSema().MarkThisReferenced(E);
  return E;
}

return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit());
12225}

12227template<typename Derived>
12228ExprResult
12229TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
                                        E->isThrownVariableInScope());
12240}

12242template<typename Derived>
12243ExprResult
12244TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
if (!Param)
  return ExprError();

ExprResult InitRes;
if (E->hasRewrittenInit()) {
  InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
  if (InitRes.isInvalid())
    return ExprError();
}

if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
    E->getUsedContext() == SemaRef.CurContext &&
    InitRes.get() == E->getRewrittenExpr())
  return E;

return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param,
                                             InitRes.get());
12264}

12266template<typename Derived>
12267ExprResult
12268TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
FieldDecl *Field = cast_or_null<FieldDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
if (!Field)
  return ExprError();

if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
    E->getUsedContext() == SemaRef.CurContext)
  return E;

return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
12279}

12281template<typename Derived>
12282ExprResult
12283TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
                                                  CXXScalarValueInitExpr *E) {
TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
if (!T)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo())
  return E;

return getDerived().RebuildCXXScalarValueInitExpr(T,
                                        /*FIXME:*/T->getTypeLoc().getEndLoc(),
                                                  E->getRParenLoc());
12296}

12298template<typename Derived>
12299ExprResult
12300TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
// Transform the type that we're allocating
TypeSourceInfo *AllocTypeInfo =
    getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
if (!AllocTypeInfo)
  return ExprError();

// Transform the size of the array we're allocating (if any).
std::optional<Expr *> ArraySize;
if (E->isArray()) {
  ExprResult NewArraySize;
  if (std::optional<Expr *> OldArraySize = E->getArraySize()) {
    NewArraySize = getDerived().TransformExpr(*OldArraySize);
    if (NewArraySize.isInvalid())
      return ExprError();
  }
  ArraySize = NewArraySize.get();
}

// Transform the placement arguments (if any).
bool ArgumentChanged = false;
SmallVector<Expr*, 8> PlacementArgs;
if (getDerived().TransformExprs(E->getPlacementArgs(),
                                E->getNumPlacementArgs(), true,
                                PlacementArgs, &ArgumentChanged))
  return ExprError();

// Transform the initializer (if any).
Expr *OldInit = E->getInitializer();
ExprResult NewInit;
if (OldInit)
  NewInit = getDerived().TransformInitializer(OldInit, true);
if (NewInit.isInvalid())
  return ExprError();

// Transform new operator and delete operator.
FunctionDecl *OperatorNew = nullptr;
if (E->getOperatorNew()) {
  OperatorNew = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
  if (!OperatorNew)
    return ExprError();
}

FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
  OperatorDelete = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
  if (!OperatorDelete)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
    ArraySize == E->getArraySize() &&
    NewInit.get() == OldInit &&
    OperatorNew == E->getOperatorNew() &&
    OperatorDelete == E->getOperatorDelete() &&
    !ArgumentChanged) {
  // Mark any declarations we need as referenced.
  // FIXME: instantiation-specific.
  if (OperatorNew)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew);
  if (OperatorDelete)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);

  if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
    QualType ElementType
      = SemaRef.Context.getBaseElementType(E->getAllocatedType());
    if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
      if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
        SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor);
      }
    }
  }

  return E;
}

QualType AllocType = AllocTypeInfo->getType();
if (!ArraySize) {
  // If no array size was specified, but the new expression was
  // instantiated with an array type (e.g., "new T" where T is
  // instantiated with "int[4]"), extract the outer bound from the
  // array type as our array size. We do this with constant and
  // dependently-sized array types.
  const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
  if (!ArrayT) {
    // Do nothing
  } else if (const ConstantArrayType *ConsArrayT
                                   = dyn_cast<ConstantArrayType>(ArrayT)) {
    ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
                                       SemaRef.Context.getSizeType(),
                                       /*FIXME:*/ E->getBeginLoc());
    AllocType = ConsArrayT->getElementType();
  } else if (const DependentSizedArrayType *DepArrayT
                            = dyn_cast<DependentSizedArrayType>(ArrayT)) {
    if (DepArrayT->getSizeExpr()) {
      ArraySize = DepArrayT->getSizeExpr();
      AllocType = DepArrayT->getElementType();
    }
  }
}

return getDerived().RebuildCXXNewExpr(
    E->getBeginLoc(), E->isGlobalNew(),
    /*FIXME:*/ E->getBeginLoc(), PlacementArgs,
    /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
    AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
12410}

12412template<typename Derived>
12413ExprResult
12414TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
ExprResult Operand = getDerived().TransformExpr(E->getArgument());
if (Operand.isInvalid())
  return ExprError();

// Transform the delete operator, if known.
FunctionDecl *OperatorDelete = nullptr;
if (E->getOperatorDelete()) {
  OperatorDelete = cast_or_null<FunctionDecl>(
      getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
  if (!OperatorDelete)
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    Operand.get() == E->getArgument() &&
    OperatorDelete == E->getOperatorDelete()) {
  // Mark any declarations we need as referenced.
  // FIXME: instantiation-specific.
  if (OperatorDelete)
    SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);

  if (!E->getArgument()->isTypeDependent()) {
    QualType Destroyed = SemaRef.Context.getBaseElementType(
                                                       E->getDestroyedType());
    if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
      SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
                                     SemaRef.LookupDestructor(Record));
    }
  }

  return E;
}

return getDerived().RebuildCXXDeleteExpr(
    E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get());
12451}

12453template<typename Derived>
12454ExprResult
12455TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
                                                   CXXPseudoDestructorExpr *E) {
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

ParsedType ObjectTypePtr;
bool MayBePseudoDestructor = false;
Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
                                            E->getOperatorLoc(),
                                      E->isArrow()? tok::arrow : tok::period,
                                            ObjectTypePtr,
                                            MayBePseudoDestructor);
if (Base.isInvalid())
  return ExprError();

QualType ObjectType = ObjectTypePtr.get();
NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
if (QualifierLoc) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
  if (!QualifierLoc)
    return ExprError();
}
CXXScopeSpec SS;
SS.Adopt(QualifierLoc);

PseudoDestructorTypeStorage Destroyed;
if (E->getDestroyedTypeInfo()) {
  TypeSourceInfo *DestroyedTypeInfo
    = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
                                              ObjectType, nullptr, SS);
  if (!DestroyedTypeInfo)
    return ExprError();
  Destroyed = DestroyedTypeInfo;
} else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
  // We aren't likely to be able to resolve the identifier down to a type
  // now anyway, so just retain the identifier.
  Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
                                          E->getDestroyedTypeLoc());
} else {
  // Look for a destructor known with the given name.
  ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
                                            *E->getDestroyedTypeIdentifier(),
                                              E->getDestroyedTypeLoc(),
                                              /*Scope=*/nullptr,
                                              SS, ObjectTypePtr,
                                              false);
  if (!T)
    return ExprError();

  Destroyed
    = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
                                               E->getDestroyedTypeLoc());
}

TypeSourceInfo *ScopeTypeInfo = nullptr;
if (E->getScopeTypeInfo()) {
  CXXScopeSpec EmptySS;
  ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
                    E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
  if (!ScopeTypeInfo)
    return ExprError();
}

return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
                                                   E->getOperatorLoc(),
                                                   E->isArrow(),
                                                   SS,
                                                   ScopeTypeInfo,
                                                   E->getColonColonLoc(),
                                                   E->getTildeLoc(),
                                                   Destroyed);
12528}

12530template <typename Derived>
12531bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old,
                                                      bool RequiresADL,
                                                      LookupResult &R) {
// Transform all the decls.
bool AllEmptyPacks = true;
for (auto *OldD : Old->decls()) {
  Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
  if (!InstD) {
    // Silently ignore these if a UsingShadowDecl instantiated to nothing.
    // This can happen because of dependent hiding.
    if (isa<UsingShadowDecl>(OldD))
      continue;
    else {
      R.clear();
      return true;
    }
  }

  // Expand using pack declarations.
  NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
  ArrayRef<NamedDecl*> Decls = SingleDecl;
  if (auto *UPD = dyn_cast<UsingPackDecl>(InstD))
    Decls = UPD->expansions();

  // Expand using declarations.
  for (auto *D : Decls) {
    if (auto *UD = dyn_cast<UsingDecl>(D)) {
      for (auto *SD : UD->shadows())
        R.addDecl(SD);
    } else {
      R.addDecl(D);
    }
  }

  AllEmptyPacks &= Decls.empty();
};

// C++ [temp.res]/8.4.2:
//   The program is ill-formed, no diagnostic required, if [...] lookup for
//   a name in the template definition found a using-declaration, but the
//   lookup in the corresponding scope in the instantiation odoes not find
//   any declarations because the using-declaration was a pack expansion and
//   the corresponding pack is empty
if (AllEmptyPacks && !RequiresADL) {
  getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
      << isa<UnresolvedMemberExpr>(Old) << Old->getName();
  return true;
}

// Resolve a kind, but don't do any further analysis.  If it's
// ambiguous, the callee needs to deal with it.
R.resolveKind();
return false;
12584}

12586template<typename Derived>
12587ExprResult
12588TreeTransform<Derived>::TransformUnresolvedLookupExpr(
                                                UnresolvedLookupExpr *Old) {
LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
               Sema::LookupOrdinaryName);

// Transform the declaration set.
if (TransformOverloadExprDecls(Old, Old->requiresADL(), R))
  return ExprError();

// Rebuild the nested-name qualifier, if present.
CXXScopeSpec SS;
if (Old->getQualifierLoc()) {
  NestedNameSpecifierLoc QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();

  SS.Adopt(QualifierLoc);
}

if (Old->getNamingClass()) {
  CXXRecordDecl *NamingClass
    = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
                                                          Old->getNameLoc(),
                                                      Old->getNamingClass()));
  if (!NamingClass) {
    R.clear();
    return ExprError();
  }

  R.setNamingClass(NamingClass);
}

SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();

// If we have neither explicit template arguments, nor the template keyword,
// it's a normal declaration name or member reference.
if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
  NamedDecl *D = R.getAsSingle<NamedDecl>();
  // In a C++11 unevaluated context, an UnresolvedLookupExpr might refer to an
  // instance member. In other contexts, BuildPossibleImplicitMemberExpr will
  // give a good diagnostic.
  if (D && D->isCXXInstanceMember()) {
    return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
                                                   /*TemplateArgs=*/nullptr,
                                                   /*Scope=*/nullptr);
  }

  return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
}

// If we have template arguments, rebuild them, then rebuild the
// templateid expression.
TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
if (Old->hasExplicitTemplateArgs() &&
    getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                            Old->getNumTemplateArgs(),
                                            TransArgs)) {
  R.clear();
  return ExprError();
}

return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
                                          Old->requiresADL(), &TransArgs);
12652}

12654template<typename Derived>
12655ExprResult
12656TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
bool ArgChanged = false;
SmallVector<TypeSourceInfo *, 4> Args;
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
  TypeSourceInfo *From = E->getArg(I);
  TypeLoc FromTL = From->getTypeLoc();
  if (!FromTL.getAs<PackExpansionTypeLoc>()) {
    TypeLocBuilder TLB;
    TLB.reserve(FromTL.getFullDataSize());
    QualType To = getDerived().TransformType(TLB, FromTL);
    if (To.isNull())
      return ExprError();

    if (To == From->getType())
      Args.push_back(From);
    else {
      Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
      ArgChanged = true;
    }
    continue;
  }

  ArgChanged = true;

  // We have a pack expansion. Instantiate it.
  PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
  TypeLoc PatternTL = ExpansionTL.getPatternLoc();
  SmallVector<UnexpandedParameterPack, 2> Unexpanded;
  SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);

  // Determine whether the set of unexpanded parameter packs can and should
  // be expanded.
  bool Expand = true;
  bool RetainExpansion = false;
  std::optional<unsigned> OrigNumExpansions =
      ExpansionTL.getTypePtr()->getNumExpansions();
  std::optional<unsigned> NumExpansions = OrigNumExpansions;
  if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                           PatternTL.getSourceRange(),
                                           Unexpanded,
                                           Expand, RetainExpansion,
                                           NumExpansions))
    return ExprError();

  if (!Expand) {
    // The transform has determined that we should perform a simple
    // transformation on the pack expansion, producing another pack
    // expansion.
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

    TypeLocBuilder TLB;
    TLB.reserve(From->getTypeLoc().getFullDataSize());

    QualType To = getDerived().TransformType(TLB, PatternTL);
    if (To.isNull())
      return ExprError();

    To = getDerived().RebuildPackExpansionType(To,
                                               PatternTL.getSourceRange(),
                                               ExpansionTL.getEllipsisLoc(),
                                               NumExpansions);
    if (To.isNull())
      return ExprError();

    PackExpansionTypeLoc ToExpansionTL
      = TLB.push<PackExpansionTypeLoc>(To);
    ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
    Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
    continue;
  }

  // Expand the pack expansion by substituting for each argument in the
  // pack(s).
  for (unsigned I = 0; I != *NumExpansions; ++I) {
    Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
    TypeLocBuilder TLB;
    TLB.reserve(PatternTL.getFullDataSize());
    QualType To = getDerived().TransformType(TLB, PatternTL);
    if (To.isNull())
      return ExprError();

    if (To->containsUnexpandedParameterPack()) {
      To = getDerived().RebuildPackExpansionType(To,
                                                 PatternTL.getSourceRange(),
                                                 ExpansionTL.getEllipsisLoc(),
                                                 NumExpansions);
      if (To.isNull())
        return ExprError();

      PackExpansionTypeLoc ToExpansionTL
        = TLB.push<PackExpansionTypeLoc>(To);
      ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
    }

    Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
  }

  if (!RetainExpansion)
    continue;

  // If we're supposed to retain a pack expansion, do so by temporarily
  // forgetting the partially-substituted parameter pack.
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  TypeLocBuilder TLB;
  TLB.reserve(From->getTypeLoc().getFullDataSize());

  QualType To = getDerived().TransformType(TLB, PatternTL);
  if (To.isNull())
    return ExprError();

  To = getDerived().RebuildPackExpansionType(To,
                                             PatternTL.getSourceRange(),
                                             ExpansionTL.getEllipsisLoc(),
                                             NumExpansions);
  if (To.isNull())
    return ExprError();

  PackExpansionTypeLoc ToExpansionTL
    = TLB.push<PackExpansionTypeLoc>(To);
  ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
  Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
}

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return E;

return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
                                     E->getEndLoc());
12785}

12787template<typename Derived>
12788ExprResult
12789TreeTransform<Derived>::TransformConceptSpecializationExpr(
                                               ConceptSpecializationExpr *E) {
const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                            Old->NumTemplateArgs, TransArgs))
  return ExprError();

return getDerived().RebuildConceptSpecializationExpr(
    E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
    E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
    &TransArgs);
12801}

12803template<typename Derived>
12804ExprResult
12805TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
SmallVector<ParmVarDecl*, 4> TransParams;
SmallVector<QualType, 4> TransParamTypes;
Sema::ExtParameterInfoBuilder ExtParamInfos;

// C++2a [expr.prim.req]p2
// Expressions appearing within a requirement-body are unevaluated operands.
EnterExpressionEvaluationContext Ctx(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
    Sema::ReuseLambdaContextDecl);

RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(
    getSema().Context, getSema().CurContext,
    E->getBody()->getBeginLoc());

Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false);

ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams(
    E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body,
    E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);

for (ParmVarDecl *Param : TransParams)
  if (Param)
    Param->setDeclContext(Body);

// On failure to transform, TransformRequiresTypeParams returns an expression
// in the event that the transformation of the type params failed in some way.
// It is expected that this will result in a 'not satisfied' Requires clause
// when instantiating.
if (!TypeParamResult.isUnset())
  return TypeParamResult;

SmallVector<concepts::Requirement *, 4> TransReqs;
if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
                                                   TransReqs))
  return ExprError();

for (concepts::Requirement *Req : TransReqs) {
  if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
    if (ER->getReturnTypeRequirement().isTypeConstraint()) {
      ER->getReturnTypeRequirement()
              .getTypeConstraintTemplateParameterList()->getParam(0)
              ->setDeclContext(Body);
    }
  }
}

return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
                                        TransParams, TransReqs,
                                        E->getRBraceLoc());
12855}

12857template<typename Derived>
12858bool TreeTransform<Derived>::TransformRequiresExprRequirements(
  ArrayRef<concepts::Requirement *> Reqs,
  SmallVectorImpl<concepts::Requirement *> &Transformed) {
for (concepts::Requirement *Req : Reqs) {
  concepts::Requirement *TransReq = nullptr;
  if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
    TransReq = getDerived().TransformTypeRequirement(TypeReq);
  else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
    TransReq = getDerived().TransformExprRequirement(ExprReq);
  else
    TransReq = getDerived().TransformNestedRequirement(
                   cast<concepts::NestedRequirement>(Req));
  if (!TransReq)
    return true;
  Transformed.push_back(TransReq);
}
return false;
12875}

12877template<typename Derived>
12878concepts::TypeRequirement *
12879TreeTransform<Derived>::TransformTypeRequirement(
  concepts::TypeRequirement *Req) {
if (Req->isSubstitutionFailure()) {
  if (getDerived().AlwaysRebuild())
    return getDerived().RebuildTypeRequirement(
            Req->getSubstitutionDiagnostic());
  return Req;
}
TypeSourceInfo *TransType = getDerived().TransformType(Req->getType());
if (!TransType)
  return nullptr;
return getDerived().RebuildTypeRequirement(TransType);
12891}

12893template<typename Derived>
12894concepts::ExprRequirement *
12895TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) {
llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr;
if (Req->isExprSubstitutionFailure())
  TransExpr = Req->getExprSubstitutionDiagnostic();
else {
  ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr());
  if (TransExprRes.isUsable() && TransExprRes.get()->hasPlaceholderType())
    TransExprRes = SemaRef.CheckPlaceholderExpr(TransExprRes.get());
  if (TransExprRes.isInvalid())
    return nullptr;
  TransExpr = TransExprRes.get();
}

std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
const auto &RetReq = Req->getReturnTypeRequirement();
if (RetReq.isEmpty())
  TransRetReq.emplace();
else if (RetReq.isSubstitutionFailure())
  TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
else if (RetReq.isTypeConstraint()) {
  TemplateParameterList *OrigTPL =
      RetReq.getTypeConstraintTemplateParameterList();
  TemplateParameterList *TPL =
      getDerived().TransformTemplateParameterList(OrigTPL);
  if (!TPL)
    return nullptr;
  TransRetReq.emplace(TPL);
}
assert(TransRetReq && "All code paths leading here must set TransRetReq")(static_cast <bool> (TransRetReq && "All code paths leading here must set TransRetReq"
) ? void (0) : __assert_fail ("TransRetReq && \"All code paths leading here must set TransRetReq\""
, "clang/lib/Sema/TreeTransform.h", 12923, __extension__ __PRETTY_FUNCTION__
));
if (Expr *E = TransExpr.dyn_cast<Expr *>())
  return getDerived().RebuildExprRequirement(E, Req->isSimple(),
                                             Req->getNoexceptLoc(),
                                             std::move(*TransRetReq));
return getDerived().RebuildExprRequirement(
    TransExpr.get<concepts::Requirement::SubstitutionDiagnostic *>(),
    Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
12931}

12933template<typename Derived>
12934concepts::NestedRequirement *
12935TreeTransform<Derived>::TransformNestedRequirement(
  concepts::NestedRequirement *Req) {
if (Req->hasInvalidConstraint()) {
  if (getDerived().AlwaysRebuild())
    return getDerived().RebuildNestedRequirement(
        Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction());
  return Req;
}
ExprResult TransConstraint =
    getDerived().TransformExpr(Req->getConstraintExpr());
if (TransConstraint.isInvalid())
  return nullptr;
return getDerived().RebuildNestedRequirement(TransConstraint.get());
12948}

12950template<typename Derived>
12951ExprResult
12952TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
if (!T)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getQueriedTypeSourceInfo())
  return E;

ExprResult SubExpr;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
  SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
  if (SubExpr.isInvalid())
    return ExprError();

  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
    return E;
}

return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T,
                                          SubExpr.get(), E->getEndLoc());
12975}

12977template<typename Derived>
12978ExprResult
12979TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
ExprResult SubExpr;
{
  EnterExpressionEvaluationContext Unevaluated(
      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
  SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
  if (SubExpr.isInvalid())
    return ExprError();

  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
    return E;
}

return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(),
                                           SubExpr.get(), E->getEndLoc());
12994}

12996template <typename Derived>
12997ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
  ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
  TypeSourceInfo **RecoveryTSI) {
ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
    DRE, AddrTaken, RecoveryTSI);

// Propagate both errors and recovered types, which return ExprEmpty.
if (!NewDRE.isUsable())
  return NewDRE;

// We got an expr, wrap it up in parens.
if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
  return PE;
return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
                                     PE->getRParen());
13012}

13014template <typename Derived>
13015ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
  DependentScopeDeclRefExpr *E) {
return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
                                          nullptr);
13019}

13021template <typename Derived>
13022ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
  DependentScopeDeclRefExpr *E, bool IsAddressOfOperand,
  TypeSourceInfo **RecoveryTSI) {
assert(E->getQualifierLoc())(static_cast <bool> (E->getQualifierLoc()) ? void (0
) : __assert_fail ("E->getQualifierLoc()", "clang/lib/Sema/TreeTransform.h"
, 13025, __extension__ __PRETTY_FUNCTION__));
NestedNameSpecifierLoc QualifierLoc =
    getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
if (!QualifierLoc)
  return ExprError();
SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.

DeclarationNameInfo NameInfo =
    getDerived().TransformDeclarationNameInfo(E->getNameInfo());
if (!NameInfo.getName())
  return ExprError();

if (!E->hasExplicitTemplateArgs()) {
  if (!getDerived().AlwaysRebuild() && QualifierLoc == E->getQualifierLoc() &&
      // Note: it is sufficient to compare the Name component of NameInfo:
      // if name has not changed, DNLoc has not changed either.
      NameInfo.getName() == E->getDeclName())
    return E;

  return getDerived().RebuildDependentScopeDeclRefExpr(
      QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
      IsAddressOfOperand, RecoveryTSI);
}

TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(
        E->getTemplateArgs(), E->getNumTemplateArgs(), TransArgs))
  return ExprError();

return getDerived().RebuildDependentScopeDeclRefExpr(
    QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
    RecoveryTSI);
13061}

13063template<typename Derived>
13064ExprResult
13065TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
// CXXConstructExprs other than for list-initialization and
// CXXTemporaryObjectExpr are always implicit, so when we have
// a 1-argument construction we just transform that argument.
if (getDerived().AllowSkippingCXXConstructExpr() &&
    ((E->getNumArgs() == 1 ||
      (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
     (!getDerived().DropCallArgument(E->getArg(0))) &&
     !E->isListInitialization()))
  return getDerived().TransformInitializer(E->getArg(0),
                                           /*DirectInit*/ false);

TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());

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

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                  &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getType() &&
    Constructor == E->getConstructor() &&
    !ArgumentChanged) {
  // Mark the constructor as referenced.
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return E;
}

return getDerived().RebuildCXXConstructExpr(
    T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
    E->hadMultipleCandidates(), E->isListInitialization(),
    E->isStdInitListInitialization(), E->requiresZeroInitialization(),
    E->getConstructionKind(), E->getParenOrBraceRange());
13114}

13116template<typename Derived>
13117ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
  CXXInheritedCtorInitExpr *E) {
QualType T = getDerived().TransformType(E->getType());
if (T.isNull())
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    T == E->getType() &&
    Constructor == E->getConstructor()) {
  // Mark the constructor as referenced.
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return E;
}

return getDerived().RebuildCXXInheritedCtorInitExpr(
    T, E->getLocation(), Constructor,
    E->constructsVBase(), E->inheritedFromVBase());
13140}

13142/// Transform a C++ temporary-binding expression.
13143///
13144/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
13145/// transform the subexpression and return that.
13146template<typename Derived>
13147ExprResult
13148TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
if (auto *Dtor = E->getTemporary()->getDestructor())
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
                                 const_cast<CXXDestructorDecl *>(Dtor));
return getDerived().TransformExpr(E->getSubExpr());
13153}

13155/// Transform a C++ expression that contains cleanups that should
13156/// be run after the expression is evaluated.
13157///
13158/// Since ExprWithCleanups nodes are implicitly generated, we
13159/// just transform the subexpression and return that.
13160template<typename Derived>
13161ExprResult
13162TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
return getDerived().TransformExpr(E->getSubExpr());
13164}

13166template<typename Derived>
13167ExprResult
13168TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
                                                  CXXTemporaryObjectExpr *E) {
TypeSourceInfo *T =
    getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
  return ExprError();

CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
    getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
if (!Constructor)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                     &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo() &&
    Constructor == E->getConstructor() &&
    !ArgumentChanged) {
  // FIXME: Instantiation-specific
  SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
  return SemaRef.MaybeBindToTemporary(E);
}

// FIXME: We should just pass E->isListInitialization(), but we're not
// prepared to handle list-initialization without a child InitListExpr.
SourceLocation LParenLoc = T->getTypeLoc().getEndLoc();
return getDerived().RebuildCXXTemporaryObjectExpr(
    T, LParenLoc, Args, E->getEndLoc(),
    /*ListInitialization=*/LParenLoc.isInvalid());
13207}

13209template<typename Derived>
13210ExprResult
13211TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
// Transform any init-capture expressions before entering the scope of the
// lambda body, because they are not semantically within that scope.
typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
struct TransformedInitCapture {
  // The location of the ... if the result is retaining a pack expansion.
  SourceLocation EllipsisLoc;
  // Zero or more expansions of the init-capture.
  SmallVector<InitCaptureInfoTy, 4> Expansions;
};
SmallVector<TransformedInitCapture, 4> InitCaptures;
InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                  CEnd = E->capture_end();
     C != CEnd; ++C) {
  if (!E->isInitCapture(C))
    continue;

  TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
  auto *OldVD = cast<VarDecl>(C->getCapturedVar());

  auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
                              std::optional<unsigned> NumExpansions) {
    ExprResult NewExprInitResult = getDerived().TransformInitializer(
        OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);

    if (NewExprInitResult.isInvalid()) {
      Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType()));
      return;
    }
    Expr *NewExprInit = NewExprInitResult.get();

    QualType NewInitCaptureType =
        getSema().buildLambdaInitCaptureInitialization(
            C->getLocation(), C->getCaptureKind() == LCK_ByRef,
            EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
            cast<VarDecl>(C->getCapturedVar())->getInitStyle() !=
                VarDecl::CInit,
            NewExprInit);
    Result.Expansions.push_back(
        InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
  };

  // If this is an init-capture pack, consider expanding the pack now.
  if (OldVD->isParameterPack()) {
    PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
                                           ->getTypeLoc()
                                           .castAs<PackExpansionTypeLoc>();
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded);

    // Determine whether the set of unexpanded parameter packs can and should
    // be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> OrigNumExpansions =
        ExpansionTL.getTypePtr()->getNumExpansions();
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    if (getDerived().TryExpandParameterPacks(
            ExpansionTL.getEllipsisLoc(),
            OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
            RetainExpansion, NumExpansions))
      return ExprError();
    if (Expand) {
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        SubstInitCapture(SourceLocation(), std::nullopt);
      }
    }
    if (!Expand || RetainExpansion) {
      ForgetPartiallySubstitutedPackRAII Forget(getDerived());
      SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
      Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
    }
  } else {
    SubstInitCapture(SourceLocation(), std::nullopt);
  }
}

LambdaScopeInfo *LSI = getSema().PushLambdaScope();
Sema::FunctionScopeRAII FuncScopeCleanup(getSema());

// Create the local class that will describe the lambda.

// FIXME: DependencyKind below is wrong when substituting inside a templated
// context that isn't a DeclContext (such as a variable template), or when
// substituting an unevaluated lambda inside of a function's parameter's type
// - as parameter types are not instantiated from within a function's DC. We
// use evaluation contexts to distinguish the function parameter case.
CXXRecordDecl::LambdaDependencyKind DependencyKind =
    CXXRecordDecl::LDK_Unknown;
if ((getSema().isUnevaluatedContext() ||
     getSema().isConstantEvaluatedContext()) &&
    (getSema().CurContext->isFileContext() ||
     !getSema().CurContext->getParent()->isDependentContext()))
  DependencyKind = CXXRecordDecl::LDK_NeverDependent;

CXXRecordDecl *OldClass = E->getLambdaClass();
CXXRecordDecl *Class = getSema().createLambdaClosureType(
    E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind,
    E->getCaptureDefault());
getDerived().transformedLocalDecl(OldClass, {Class});

CXXMethodDecl *NewCallOperator =
    getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class);
NewCallOperator->setLexicalDeclContext(getSema().CurContext);

// Enter the scope of the lambda.
getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(),
                           E->getCaptureDefault(), E->getCaptureDefaultLoc(),
                           E->hasExplicitParameters(), E->isMutable());

// Introduce the context of the call operator.
Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
                               /*NewThisContext*/false);

bool Invalid = false;

// Transform captures.
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (C->isImplicit())
    break;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
    getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
                                  /*BuildAndDiagnose*/ true, nullptr,
                                  C->getCaptureKind() == LCK_StarThis);
    continue;
  }
  // Captured expression will be recaptured during captured variables
  // rebuilding.
  if (C->capturesVLAType())
    continue;

  // Rebuild init-captures, including the implied field declaration.
  if (E->isInitCapture(C)) {
    TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];

    auto *OldVD = cast<VarDecl>(C->getCapturedVar());
    llvm::SmallVector<Decl*, 4> NewVDs;

    for (InitCaptureInfoTy &Info : NewC.Expansions) {
      ExprResult Init = Info.first;
      QualType InitQualType = Info.second;
      if (Init.isInvalid() || InitQualType.isNull()) {
        Invalid = true;
        break;
      }
      VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
          OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
          OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(),
          getSema().CurContext);
      if (!NewVD) {
        Invalid = true;
        break;
      }
      NewVDs.push_back(NewVD);
      getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef);
    }

    if (Invalid)
      break;

    getDerived().transformedLocalDecl(OldVD, NewVDs);
    continue;
  }

  assert(C->capturesVariable() && "unexpected kind of lambda capture")(static_cast <bool> (C->capturesVariable() &&
 "unexpected kind of lambda capture") ? void (0) : __assert_fail
 ("C->capturesVariable() && \"unexpected kind of lambda capture\""
, "clang/lib/Sema/TreeTransform.h", 13383, __extension__ __PRETTY_FUNCTION__
));

  // Determine the capture kind for Sema.
  Sema::TryCaptureKind Kind
    = C->isImplicit()? Sema::TryCapture_Implicit
                     : C->getCaptureKind() == LCK_ByCopy
                         ? Sema::TryCapture_ExplicitByVal
                         : Sema::TryCapture_ExplicitByRef;
  SourceLocation EllipsisLoc;
  if (C->isPackExpansion()) {
    UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
    bool ShouldExpand = false;
    bool RetainExpansion = false;
    std::optional<unsigned> NumExpansions;
    if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
                                             C->getLocation(),
                                             Unexpanded,
                                             ShouldExpand, RetainExpansion,
                                             NumExpansions)) {
      Invalid = true;
      continue;
    }

    if (ShouldExpand) {
      // The transform has determined that we should perform an expansion;
      // transform and capture each of the arguments.
      // expansion of the pattern. Do so.
      auto *Pack = cast<VarDecl>(C->getCapturedVar());
      for (unsigned I = 0; I != *NumExpansions; ++I) {
        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
        VarDecl *CapturedVar
          = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
                                                             Pack));
        if (!CapturedVar) {
          Invalid = true;
          continue;
        }

        // Capture the transformed variable.
        getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
      }

      // FIXME: Retain a pack expansion if RetainExpansion is true.

      continue;
    }

    EllipsisLoc = C->getEllipsisLoc();
  }

  // Transform the captured variable.
  auto *CapturedVar = cast_or_null<ValueDecl>(
      getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
  if (!CapturedVar || CapturedVar->isInvalidDecl()) {
    Invalid = true;
    continue;
  }

  // Capture the transformed variable.
  getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
                               EllipsisLoc);
}
getSema().finishLambdaExplicitCaptures(LSI);

// Transform the template parameters, and add them to the current
// instantiation scope. The null case is handled correctly.
auto TPL = getDerived().TransformTemplateParameterList(
    E->getTemplateParameterList());
LSI->GLTemplateParameterList = TPL;

// Transform the type of the original lambda's call operator.
// The transformation MUST be done in the CurrentInstantiationScope since
// it introduces a mapping of the original to the newly created
// transformed parameters.
TypeSourceInfo *NewCallOpTSI = nullptr;
{
  TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
  auto OldCallOpFPTL =
      OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();

  TypeLocBuilder NewCallOpTLBuilder;
  SmallVector<QualType, 4> ExceptionStorage;
  TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
  QualType NewCallOpType = TransformFunctionProtoType(
      NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(),
      [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
        return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
                                            ExceptionStorage, Changed);
      });
  if (NewCallOpType.isNull())
    return ExprError();
  NewCallOpTSI =
      NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType);
}

getSema().CompleteLambdaCallOperator(
    NewCallOperator, E->getCallOperator()->getLocation(),
    E->getCallOperator()->getInnerLocStart(),
    E->getCallOperator()->getTrailingRequiresClause(), NewCallOpTSI,
    E->getCallOperator()->getConstexprKind(),
    E->getCallOperator()->getStorageClass(),
    NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
    E->hasExplicitResultType());

getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});

{
  // Number the lambda for linkage purposes if necessary.
  Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext());

  std::optional<CXXRecordDecl::LambdaNumbering> Numbering;
  if (getDerived().ReplacingOriginal()) {
    Numbering = OldClass->getLambdaNumbering();
  }

  getSema().handleLambdaNumbering(Class, NewCallOperator, Numbering);
}

// FIXME: Sema's lambda-building mechanism expects us to push an expression
// evaluation context even if we're not transforming the function body.
getSema().PushExpressionEvaluationContext(
    Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

// Instantiate the body of the lambda expression.
StmtResult Body =
    Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody());

// ActOnLambda* will pop the function scope for us.
FuncScopeCleanup.disable();

if (Body.isInvalid()) {
  SavedContext.pop();
  getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr,
                             /*IsInstantiation=*/true);
  return ExprError();
}

// Copy the LSI before ActOnFinishFunctionBody removes it.
// FIXME: This is dumb. Store the lambda information somewhere that outlives
// the call operator.
auto LSICopy = *LSI;
getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
                                  /*IsInstantiation*/ true);
SavedContext.pop();

return getSema().BuildLambdaExpr(E->getBeginLoc(), Body.get()->getEndLoc(),
                                 &LSICopy);
13531}

13533template<typename Derived>
13534StmtResult
13535TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) {
return TransformStmt(S);
13537}

13539template<typename Derived>
13540StmtResult
13541TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) {
// Transform captures.
for (LambdaExpr::capture_iterator C = E->capture_begin(),
                               CEnd = E->capture_end();
     C != CEnd; ++C) {
  // When we hit the first implicit capture, tell Sema that we've finished
  // the list of explicit captures.
  if (!C->isImplicit())
    continue;

  // Capturing 'this' is trivial.
  if (C->capturesThis()) {
    getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
                                  /*BuildAndDiagnose*/ true, nullptr,
                                  C->getCaptureKind() == LCK_StarThis);
    continue;
  }
  // Captured expression will be recaptured during captured variables
  // rebuilding.
  if (C->capturesVLAType())
    continue;

  assert(C->capturesVariable() && "unexpected kind of lambda capture")(static_cast <bool> (C->capturesVariable() &&
 "unexpected kind of lambda capture") ? void (0) : __assert_fail
 ("C->capturesVariable() && \"unexpected kind of lambda capture\""
, "clang/lib/Sema/TreeTransform.h", 13563, __extension__ __PRETTY_FUNCTION__
));
  assert(!E->isInitCapture(C) && "implicit init-capture?")(static_cast <bool> (!E->isInitCapture(C) &&
 "implicit init-capture?") ? void (0) : __assert_fail ("!E->isInitCapture(C) && \"implicit init-capture?\""
, "clang/lib/Sema/TreeTransform.h", 13564, __extension__ __PRETTY_FUNCTION__
));

  // Transform the captured variable.
  VarDecl *CapturedVar = cast_or_null<VarDecl>(
      getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
  if (!CapturedVar || CapturedVar->isInvalidDecl())
    return StmtError();

  // Capture the transformed variable.
  getSema().tryCaptureVariable(CapturedVar, C->getLocation());
}

return S;
13577}

13579template<typename Derived>
13580ExprResult
13581TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
                                                CXXUnresolvedConstructExpr *E) {
TypeSourceInfo *T =
    getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
if (!T)
  return ExprError();

bool ArgumentChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
{
  EnterExpressionEvaluationContext Context(
      getSema(), EnterExpressionEvaluationContext::InitList,
      E->isListInitialization());
  if (getDerived().TransformExprs(E->arg_begin(), E->getNumArgs(), true, Args,
                                  &ArgumentChanged))
    return ExprError();
}

if (!getDerived().AlwaysRebuild() &&
    T == E->getTypeSourceInfo() &&
    !ArgumentChanged)
  return E;

// FIXME: we're faking the locations of the commas
return getDerived().RebuildCXXUnresolvedConstructExpr(
    T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization());
13608}

13610template<typename Derived>
13611ExprResult
13612TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
                                           CXXDependentScopeMemberExpr *E) {
// Transform the base of the expression.
ExprResult Base((Expr*) nullptr);
Expr *OldBase;
QualType BaseType;
QualType ObjectType;
if (!E->isImplicitAccess()) {
  OldBase = E->getBase();
  Base = getDerived().TransformExpr(OldBase);
  if (Base.isInvalid())
    return ExprError();

  // Start the member reference and compute the object's type.
  ParsedType ObjectTy;
  bool MayBePseudoDestructor = false;
  Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
                                              E->getOperatorLoc(),
                                    E->isArrow()? tok::arrow : tok::period,
                                              ObjectTy,
                                              MayBePseudoDestructor);
  if (Base.isInvalid())
    return ExprError();

  ObjectType = ObjectTy.get();
  BaseType = ((Expr*) Base.get())->getType();
} else {
  OldBase = nullptr;
  BaseType = getDerived().TransformType(E->getBaseType());
  ObjectType = BaseType->castAs<PointerType>()->getPointeeType();
}

// Transform the first part of the nested-name-specifier that qualifies
// the member name.
NamedDecl *FirstQualifierInScope
  = getDerived().TransformFirstQualifierInScope(
                                          E->getFirstQualifierFoundInScope(),
                                          E->getQualifierLoc().getBeginLoc());

NestedNameSpecifierLoc QualifierLoc;
if (E->getQualifier()) {
  QualifierLoc
    = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
                                                   ObjectType,
                                                   FirstQualifierInScope);
  if (!QualifierLoc)
    return ExprError();
}

SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();

// TODO: If this is a conversion-function-id, verify that the
// destination type name (if present) resolves the same way after
// instantiation as it did in the local scope.

DeclarationNameInfo NameInfo
  = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
if (!NameInfo.getName())
  return ExprError();

if (!E->hasExplicitTemplateArgs()) {
  // This is a reference to a member without an explicitly-specified
  // template argument list. Optimize for this common case.
  if (!getDerived().AlwaysRebuild() &&
      Base.get() == OldBase &&
      BaseType == E->getBaseType() &&
      QualifierLoc == E->getQualifierLoc() &&
      NameInfo.getName() == E->getMember() &&
      FirstQualifierInScope == E->getFirstQualifierFoundInScope())
    return E;

  return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
                                                     BaseType,
                                                     E->isArrow(),
                                                     E->getOperatorLoc(),
                                                     QualifierLoc,
                                                     TemplateKWLoc,
                                                     FirstQualifierInScope,
                                                     NameInfo,
                                                     /*TemplateArgs*/nullptr);
}

TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
                                            E->getNumTemplateArgs(),
                                            TransArgs))
  return ExprError();

return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
                                                   BaseType,
                                                   E->isArrow(),
                                                   E->getOperatorLoc(),
                                                   QualifierLoc,
                                                   TemplateKWLoc,
                                                   FirstQualifierInScope,
                                                   NameInfo,
                                                   &TransArgs);
13709}

13711template <typename Derived>
13712ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(
  UnresolvedMemberExpr *Old) {
// Transform the base of the expression.
ExprResult Base((Expr *)nullptr);
QualType BaseType;
if (!Old->isImplicitAccess()) {
  Base = getDerived().TransformExpr(Old->getBase());
  if (Base.isInvalid())
    return ExprError();
  Base =
      getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow());
  if (Base.isInvalid())
    return ExprError();
  BaseType = Base.get()->getType();
} else {
  BaseType = getDerived().TransformType(Old->getBaseType());
}

NestedNameSpecifierLoc QualifierLoc;
if (Old->getQualifierLoc()) {
  QualifierLoc =
      getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
  if (!QualifierLoc)
    return ExprError();
}

SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();

LookupResult R(SemaRef, Old->getMemberNameInfo(), Sema::LookupOrdinaryName);

// Transform the declaration set.
if (TransformOverloadExprDecls(Old, /*RequiresADL*/ false, R))
  return ExprError();

// Determine the naming class.
if (Old->getNamingClass()) {
  CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
      getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
  if (!NamingClass)
    return ExprError();

  R.setNamingClass(NamingClass);
}

TemplateArgumentListInfo TransArgs;
if (Old->hasExplicitTemplateArgs()) {
  TransArgs.setLAngleLoc(Old->getLAngleLoc());
  TransArgs.setRAngleLoc(Old->getRAngleLoc());
  if (getDerived().TransformTemplateArguments(
          Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
    return ExprError();
}

// FIXME: to do this check properly, we will need to preserve the
// first-qualifier-in-scope here, just in case we had a dependent
// base (and therefore couldn't do the check) and a
// nested-name-qualifier (and therefore could do the lookup).
NamedDecl *FirstQualifierInScope = nullptr;

return getDerived().RebuildUnresolvedMemberExpr(
    Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
    TemplateKWLoc, FirstQualifierInScope, R,
    (Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr));
13775}

13777template<typename Derived>
13778ExprResult
13779TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
EnterExpressionEvaluationContext Unevaluated(
    SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
  return E;

return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
13790}

13792template<typename Derived>
13793ExprResult
13794TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
if (Pattern.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
  return E;

return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
                                         E->getNumExpansions());
13804}

13806template<typename Derived>
13807ExprResult
13808TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
// If E is not value-dependent, then nothing will change when we transform it.
// Note: This is an instantiation-centric view.
if (!E->isValueDependent())
  return E;

EnterExpressionEvaluationContext Unevaluated(
    getSema(), Sema::ExpressionEvaluationContext::Unevaluated);

ArrayRef<TemplateArgument> PackArgs;
TemplateArgument ArgStorage;

// Find the argument list to transform.
if (E->isPartiallySubstituted()) {
  PackArgs = E->getPartialArguments();
} else if (E->isValueDependent()) {
  UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
  bool ShouldExpand = false;
  bool RetainExpansion = false;
  std::optional<unsigned> NumExpansions;
  if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
                                           Unexpanded,
                                           ShouldExpand, RetainExpansion,
                                           NumExpansions))
    return ExprError();

  // If we need to expand the pack, build a template argument from it and
  // expand that.
  if (ShouldExpand) {
    auto *Pack = E->getPack();
    if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
      ArgStorage = getSema().Context.getPackExpansionType(
          getSema().Context.getTypeDeclType(TTPD), std::nullopt);
    } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
      ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt);
    } else {
      auto *VD = cast<ValueDecl>(Pack);
      ExprResult DRE = getSema().BuildDeclRefExpr(
          VD, VD->getType().getNonLValueExprType(getSema().Context),
          VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue,
          E->getPackLoc());
      if (DRE.isInvalid())
        return ExprError();
      ArgStorage = new (getSema().Context)
          PackExpansionExpr(getSema().Context.DependentTy, DRE.get(),
                            E->getPackLoc(), std::nullopt);
    }
    PackArgs = ArgStorage;
  }
}

// If we're not expanding the pack, just transform the decl.
if (!PackArgs.size()) {
  auto *Pack = cast_or_null<NamedDecl>(
      getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
  if (!Pack)
    return ExprError();
  return getDerived().RebuildSizeOfPackExpr(
      E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(),
      std::nullopt, std::nullopt);
}

// Try to compute the result without performing a partial substitution.
std::optional<unsigned> Result = 0;
for (const TemplateArgument &Arg : PackArgs) {
  if (!Arg.isPackExpansion()) {
    Result = *Result + 1;
    continue;
  }

  TemplateArgumentLoc ArgLoc;
  InventTemplateArgumentLoc(Arg, ArgLoc);

  // Find the pattern of the pack expansion.
  SourceLocation Ellipsis;
  std::optional<unsigned> OrigNumExpansions;
  TemplateArgumentLoc Pattern =
      getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
                                                        OrigNumExpansions);

  // Substitute under the pack expansion. Do not expand the pack (yet).
  TemplateArgumentLoc OutPattern;
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
  if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
                                             /*Uneval*/ true))
    return true;

  // See if we can determine the number of arguments from the result.
  std::optional<unsigned> NumExpansions =
      getSema().getFullyPackExpandedSize(OutPattern.getArgument());
  if (!NumExpansions) {
    // No: we must be in an alias template expansion, and we're going to need
    // to actually expand the packs.
    Result = std::nullopt;
    break;
  }

  Result = *Result + *NumExpansions;
}

// Common case: we could determine the number of expansions without
// substituting.
if (Result)
  return getDerived().RebuildSizeOfPackExpr(
      E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
      *Result, std::nullopt);

TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
                                             E->getPackLoc());
{
  TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
  typedef TemplateArgumentLocInventIterator<
      Derived, const TemplateArgument*> PackLocIterator;
  if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
                                 PackLocIterator(*this, PackArgs.end()),
                                 TransformedPackArgs, /*Uneval*/true))
    return ExprError();
}

// Check whether we managed to fully-expand the pack.
// FIXME: Is it possible for us to do so and not hit the early exit path?
SmallVector<TemplateArgument, 8> Args;
bool PartialSubstitution = false;
for (auto &Loc : TransformedPackArgs.arguments()) {
  Args.push_back(Loc.getArgument());
  if (Loc.getArgument().isPackExpansion())
    PartialSubstitution = true;
}

if (PartialSubstitution)
  return getDerived().RebuildSizeOfPackExpr(
      E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
      std::nullopt, Args);

return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
                                          E->getPackLoc(), E->getRParenLoc(),
                                          Args.size(), std::nullopt);
13945}

13947template<typename Derived>
13948ExprResult
13949TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
                                        SubstNonTypeTemplateParmPackExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
13953}

13955template<typename Derived>
13956ExprResult
13957TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
                                        SubstNonTypeTemplateParmExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
13961}

13963template<typename Derived>
13964ExprResult
13965TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
// Default behavior is to do nothing with this transformation.
return E;
13968}

13970template<typename Derived>
13971ExprResult
13972TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
                                                MaterializeTemporaryExpr *E) {
return getDerived().TransformExpr(E->getSubExpr());
13975}

13977template<typename Derived>
13978ExprResult
13979TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
UnresolvedLookupExpr *Callee = nullptr;
if (Expr *OldCallee = E->getCallee()) {
  ExprResult CalleeResult = getDerived().TransformExpr(OldCallee);
  if (CalleeResult.isInvalid())
    return ExprError();
  Callee = cast<UnresolvedLookupExpr>(CalleeResult.get());
}

Expr *Pattern = E->getPattern();

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 13992, __extension__ __PRETTY_FUNCTION__
));

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

if (!Expand) {
  // Do not expand any packs here, just transform and rebuild a fold
  // expression.
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);

  ExprResult LHS =
      E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
  if (LHS.isInvalid())
    return true;

  ExprResult RHS =
      E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
  if (RHS.isInvalid())
    return true;

  if (!getDerived().AlwaysRebuild() &&
      LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
    return E;

  return getDerived().RebuildCXXFoldExpr(
      Callee, E->getBeginLoc(), LHS.get(), E->getOperator(),
      E->getEllipsisLoc(), RHS.get(), E->getEndLoc(), NumExpansions);
}

// Formally a fold expression expands to nested parenthesized expressions.
// Enforce this limit to avoid creating trees so deep we can't safely traverse
// them.
if (NumExpansions && SemaRef.getLangOpts().BracketDepth < NumExpansions) {
  SemaRef.Diag(E->getEllipsisLoc(),
               clang::diag::err_fold_expression_limit_exceeded)
      << *NumExpansions << SemaRef.getLangOpts().BracketDepth
      << E->getSourceRange();
  SemaRef.Diag(E->getEllipsisLoc(), diag::note_bracket_depth);
  return ExprError();
}

// The transform has determined that we should perform an elementwise
// expansion of the pattern. Do so.
ExprResult Result = getDerived().TransformExpr(E->getInit());
if (Result.isInvalid())
  return true;
bool LeftFold = E->isLeftFold();

// If we're retaining an expansion for a right fold, it is the innermost
// component and takes the init (if any).
if (!LeftFold && RetainExpansion) {
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  Result = getDerived().RebuildCXXFoldExpr(
      Callee, E->getBeginLoc(), Out.get(), E->getOperator(),
      E->getEllipsisLoc(), Result.get(), E->getEndLoc(), OrigNumExpansions);
  if (Result.isInvalid())
    return true;
}

for (unsigned I = 0; I != *NumExpansions; ++I) {
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
      getSema(), LeftFold ? I : *NumExpansions - I - 1);
  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  if (Out.get()->containsUnexpandedParameterPack()) {
    // We still have a pack; retain a pack expansion for this slice.
    Result = getDerived().RebuildCXXFoldExpr(
        Callee, E->getBeginLoc(), LeftFold ? Result.get() : Out.get(),
        E->getOperator(), E->getEllipsisLoc(),
        LeftFold ? Out.get() : Result.get(), E->getEndLoc(),
        OrigNumExpansions);
  } else if (Result.isUsable()) {
    // We've got down to a single element; build a binary operator.
    Expr *LHS = LeftFold ? Result.get() : Out.get();
    Expr *RHS = LeftFold ? Out.get() : Result.get();
    if (Callee)
      Result = getDerived().RebuildCXXOperatorCallExpr(
          BinaryOperator::getOverloadedOperator(E->getOperator()),
          E->getEllipsisLoc(), Callee, LHS, RHS);
    else
      Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(),
                                                  E->getOperator(), LHS, RHS);
  } else
    Result = Out;

  if (Result.isInvalid())
    return true;
}

// If we're retaining an expansion for a left fold, it is the outermost
// component and takes the complete expansion so far as its init (if any).
if (LeftFold && RetainExpansion) {
  ForgetPartiallySubstitutedPackRAII Forget(getDerived());

  ExprResult Out = getDerived().TransformExpr(Pattern);
  if (Out.isInvalid())
    return true;

  Result = getDerived().RebuildCXXFoldExpr(
      Callee, E->getBeginLoc(), Result.get(), E->getOperator(),
      E->getEllipsisLoc(), Out.get(), E->getEndLoc(), OrigNumExpansions);
  if (Result.isInvalid())
    return true;
}

// If we had no init and an empty pack, and we're not retaining an expansion,
// then produce a fallback value or error.
if (Result.isUnset())
  return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
                                              E->getOperator());

return Result;
14121}

14123template <typename Derived>
14124ExprResult
14125TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) {
SmallVector<Expr *, 4> TransformedInits;
ArrayRef<Expr *> InitExprs = E->getInitExprs();
if (TransformExprs(InitExprs.data(), InitExprs.size(), true,
                   TransformedInits))
  return ExprError();

return getDerived().RebuildParenListExpr(E->getBeginLoc(), TransformedInits,
                                         E->getEndLoc());
14134}

14136template<typename Derived>
14137ExprResult
14138TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
  CXXStdInitializerListExpr *E) {
return getDerived().TransformExpr(E->getSubExpr());
14141}

14143template<typename Derived>
14144ExprResult
14145TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
return SemaRef.MaybeBindToTemporary(E);
14147}

14149template<typename Derived>
14150ExprResult
14151TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
return E;
14153}

14155template<typename Derived>
14156ExprResult
14157TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
if (SubExpr.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    SubExpr.get() == E->getSubExpr())
  return E;

return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
14167}

14169template<typename Derived>
14170ExprResult
14171TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
// Transform each of the elements.
SmallVector<Expr *, 8> Elements;
bool ArgChanged = false;
if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
                                /*IsCall=*/false, Elements, &ArgChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
                                            Elements.data(),
                                            Elements.size());
14185}

14187template<typename Derived>
14188ExprResult
14189TreeTransform<Derived>::TransformObjCDictionaryLiteral(
                                                  ObjCDictionaryLiteral *E) {
// Transform each of the elements.
SmallVector<ObjCDictionaryElement, 8> Elements;
bool ArgChanged = false;
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
  ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);

  if (OrigElement.isPackExpansion()) {
    // This key/value element is a pack expansion.
    SmallVector<UnexpandedParameterPack, 2> Unexpanded;
    getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
    getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
    assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")(static_cast <bool> (!Unexpanded.empty() && "Pack expansion without parameter packs?"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Pack expansion without parameter packs?\""
, "clang/lib/Sema/TreeTransform.h", 14202, __extension__ __PRETTY_FUNCTION__
));

    // Determine whether the set of unexpanded parameter packs can
    // and should be expanded.
    bool Expand = true;
    bool RetainExpansion = false;
    std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
    std::optional<unsigned> NumExpansions = OrigNumExpansions;
    SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
                             OrigElement.Value->getEndLoc());
    if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
                                             PatternRange, Unexpanded, Expand,
                                             RetainExpansion, NumExpansions))
      return ExprError();

    if (!Expand) {
      // The transform has determined that we should perform a simple
      // transformation on the pack expansion, producing another pack
      // expansion.
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
      ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
      if (Key.isInvalid())
        return ExprError();

      if (Key.get() != OrigElement.Key)
        ArgChanged = true;

      ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
      if (Value.isInvalid())
        return ExprError();

      if (Value.get() != OrigElement.Value)
        ArgChanged = true;

      ObjCDictionaryElement Expansion = {
        Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
      };
      Elements.push_back(Expansion);
      continue;
    }

    // Record right away that the argument was changed.  This needs
    // to happen even if the array expands to nothing.
    ArgChanged = true;

    // The transform has determined that we should perform an elementwise
    // expansion of the pattern. Do so.
    for (unsigned I = 0; I != *NumExpansions; ++I) {
      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
      ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
      if (Key.isInvalid())
        return ExprError();

      ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
      if (Value.isInvalid())
        return ExprError();

      ObjCDictionaryElement Element = {
        Key.get(), Value.get(), SourceLocation(), NumExpansions
      };

      // If any unexpanded parameter packs remain, we still have a
      // pack expansion.
      // FIXME: Can this really happen?
      if (Key.get()->containsUnexpandedParameterPack() ||
          Value.get()->containsUnexpandedParameterPack())
        Element.EllipsisLoc = OrigElement.EllipsisLoc;

      Elements.push_back(Element);
    }

    // FIXME: Retain a pack expansion if RetainExpansion is true.

    // We've finished with this pack expansion.
    continue;
  }

  // Transform and check key.
  ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
  if (Key.isInvalid())
    return ExprError();

  if (Key.get() != OrigElement.Key)
    ArgChanged = true;

  // Transform and check value.
  ExprResult Value
    = getDerived().TransformExpr(OrigElement.Value);
  if (Value.isInvalid())
    return ExprError();

  if (Value.get() != OrigElement.Value)
    ArgChanged = true;

  ObjCDictionaryElement Element = {Key.get(), Value.get(), SourceLocation(),
                                   std::nullopt};
  Elements.push_back(Element);
}

if (!getDerived().AlwaysRebuild() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
                                                 Elements);
14306}

14308template<typename Derived>
14309ExprResult
14310TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
TypeSourceInfo *EncodedTypeInfo
  = getDerived().TransformType(E->getEncodedTypeSourceInfo());
if (!EncodedTypeInfo)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    EncodedTypeInfo == E->getEncodedTypeSourceInfo())
  return E;

return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
                                          EncodedTypeInfo,
                                          E->getRParenLoc());
14323}

14325template<typename Derived>
14326ExprResult TreeTransform<Derived>::
14327TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
// This is a kind of implicit conversion, and it needs to get dropped
// and recomputed for the same general reasons that ImplicitCastExprs
// do, as well a more specific one: this expression is only valid when
// it appears *immediately* as an argument expression.
return getDerived().TransformExpr(E->getSubExpr());
14333}

14335template<typename Derived>
14336ExprResult TreeTransform<Derived>::
14337TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
TypeSourceInfo *TSInfo
  = getDerived().TransformType(E->getTypeInfoAsWritten());
if (!TSInfo)
  return ExprError();

ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
if (Result.isInvalid())
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    TSInfo == E->getTypeInfoAsWritten() &&
    Result.get() == E->getSubExpr())
  return E;

return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
                                    E->getBridgeKeywordLoc(), TSInfo,
                                    Result.get());
14355}

14357template <typename Derived>
14358ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
  ObjCAvailabilityCheckExpr *E) {
return E;
14361}

14363template<typename Derived>
14364ExprResult
14365TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
// Transform arguments.
bool ArgChanged = false;
SmallVector<Expr*, 8> Args;
Args.reserve(E->getNumArgs());
if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
                                &ArgChanged))
  return ExprError();

if (E->getReceiverKind() == ObjCMessageExpr::Class) {
  // Class message: transform the receiver type.
  TypeSourceInfo *ReceiverTypeInfo
    = getDerived().TransformType(E->getClassReceiverTypeInfo());
  if (!ReceiverTypeInfo)
    return ExprError();

  // If nothing changed, just retain the existing message send.
  if (!getDerived().AlwaysRebuild() &&
      ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
    return SemaRef.MaybeBindToTemporary(E);

  // Build a new class message send.
  SmallVector<SourceLocation, 16> SelLocs;
  E->getSelectorLocs(SelLocs);
  return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
                                             E->getSelector(),
                                             SelLocs,
                                             E->getMethodDecl(),
                                             E->getLeftLoc(),
                                             Args,
                                             E->getRightLoc());
}
else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
         E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
  if (!E->getMethodDecl())
    return ExprError();

  // Build a new class message send to 'super'.
  SmallVector<SourceLocation, 16> SelLocs;
  E->getSelectorLocs(SelLocs);
  return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
                                             E->getSelector(),
                                             SelLocs,
                                             E->getReceiverType(),
                                             E->getMethodDecl(),
                                             E->getLeftLoc(),
                                             Args,
                                             E->getRightLoc());
}

// Instance message: transform the receiver
assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&(static_cast <bool> (E->getReceiverKind() == ObjCMessageExpr
::Instance && "Only class and instance messages may be instantiated"
) ? void (0) : __assert_fail ("E->getReceiverKind() == ObjCMessageExpr::Instance && \"Only class and instance messages may be instantiated\""
, "clang/lib/Sema/TreeTransform.h", 14417, __extension__ __PRETTY_FUNCTION__
))
       "Only class and instance messages may be instantiated")(static_cast <bool> (E->getReceiverKind() == ObjCMessageExpr
::Instance && "Only class and instance messages may be instantiated"
) ? void (0) : __assert_fail ("E->getReceiverKind() == ObjCMessageExpr::Instance && \"Only class and instance messages may be instantiated\""
, "clang/lib/Sema/TreeTransform.h", 14417, __extension__ __PRETTY_FUNCTION__
));
ExprResult Receiver
  = getDerived().TransformExpr(E->getInstanceReceiver());
if (Receiver.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing message send.
if (!getDerived().AlwaysRebuild() &&
    Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
  return SemaRef.MaybeBindToTemporary(E);

// Build a new instance message send.
SmallVector<SourceLocation, 16> SelLocs;
E->getSelectorLocs(SelLocs);
return getDerived().RebuildObjCMessageExpr(Receiver.get(),
                                           E->getSelector(),
                                           SelLocs,
                                           E->getMethodDecl(),
                                           E->getLeftLoc(),
                                           Args,
                                           E->getRightLoc());
14438}

14440template<typename Derived>
14441ExprResult
14442TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
return E;
14444}

14446template<typename Derived>
14447ExprResult
14448TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
return E;
14450}

14452template<typename Derived>
14453ExprResult
14454TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// We don't need to transform the ivar; it will never change.

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
                                           E->getLocation(),
                                           E->isArrow(), E->isFreeIvar());
14470}

14472template<typename Derived>
14473ExprResult
14474TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
// 'super' and types never change. Property never changes. Just
// retain the existing expression.
if (!E->isObjectReceiver())
  return E;

// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// We don't need to transform the property; it will never change.

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

if (E->isExplicitProperty())
  return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
                                                 E->getExplicitProperty(),
                                                 E->getLocation());

return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
                                               SemaRef.Context.PseudoObjectTy,
                                               E->getImplicitPropertyGetter(),
                                               E->getImplicitPropertySetter(),
                                               E->getLocation());
14502}

14504template<typename Derived>
14505ExprResult
14506TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
if (Base.isInvalid())
  return ExprError();

// Transform the key expression.
ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
if (Key.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
  return E;

return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
                                                Base.get(), Key.get(),
                                                E->getAtIndexMethodDecl(),
                                                E->setAtIndexMethodDecl());
14526}

14528template<typename Derived>
14529ExprResult
14530TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
// Transform the base expression.
ExprResult Base = getDerived().TransformExpr(E->getBase());
if (Base.isInvalid())
  return ExprError();

// If nothing changed, just retain the existing expression.
if (!getDerived().AlwaysRebuild() &&
    Base.get() == E->getBase())
  return E;

return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
                                       E->getOpLoc(),
                                       E->isArrow());
14544}

14546template<typename Derived>
14547ExprResult
14548TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 8> SubExprs;
SubExprs.reserve(E->getNumSubExprs());
if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
                                SubExprs, &ArgumentChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    !ArgumentChanged)
  return E;

return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
                                             SubExprs,
                                             E->getRParenLoc());
14563}

14565template<typename Derived>
14566ExprResult
14567TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
if (SrcExpr.isInvalid())
  return ExprError();

TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
if (!Type)
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    Type == E->getTypeSourceInfo() &&
    SrcExpr.get() == E->getSrcExpr())
  return E;

return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
                                             SrcExpr.get(), Type,
                                             E->getRParenLoc());
14584}

14586template<typename Derived>
14587ExprResult
14588TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
BlockDecl *oldBlock = E->getBlockDecl();

SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
BlockScopeInfo *blockScope = SemaRef.getCurBlock();

blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
blockScope->TheDecl->setBlockMissingReturnType(
                       oldBlock->blockMissingReturnType());

SmallVector<ParmVarDecl*, 4> params;
SmallVector<QualType, 4> paramTypes;

const FunctionProtoType *exprFunctionType = E->getFunctionType();

// Parameter substitution.
Sema::ExtParameterInfoBuilder extParamInfos;
if (getDerived().TransformFunctionTypeParams(
        E->getCaretLocation(), oldBlock->parameters(), nullptr,
        exprFunctionType->getExtParameterInfosOrNull(), paramTypes, &params,
        extParamInfos)) {
  getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
  return ExprError();
}

QualType exprResultType =
    getDerived().TransformType(exprFunctionType->getReturnType());

auto epi = exprFunctionType->getExtProtoInfo();
epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());

QualType functionType =
  getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
blockScope->FunctionType = functionType;

// Set the parameters on the block decl.
if (!params.empty())
  blockScope->TheDecl->setParams(params);

if (!oldBlock->blockMissingReturnType()) {
  blockScope->HasImplicitReturnType = false;
  blockScope->ReturnType = exprResultType;
}

// Transform the body
StmtResult body = getDerived().TransformStmt(E->getBody());
if (body.isInvalid()) {
  getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
  return ExprError();
}

14639#ifndef NDEBUG
// In builds with assertions, make sure that we captured everything we
// captured before.
if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
  for (const auto &I : oldBlock->captures()) {
    VarDecl *oldCapture = I.getVariable();

    // Ignore parameter packs.
    if (oldCapture->isParameterPack())
      continue;

    VarDecl *newCapture =
      cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
                                               oldCapture));
    assert(blockScope->CaptureMap.count(newCapture))(static_cast <bool> (blockScope->CaptureMap.count(newCapture
)) ? void (0) : __assert_fail ("blockScope->CaptureMap.count(newCapture)"
, "clang/lib/Sema/TreeTransform.h", 14653, __extension__ __PRETTY_FUNCTION__
));
  }

  // The this pointer may not be captured by the instantiated block, even when
  // it's captured by the original block, if the expression causing the
  // capture is in the discarded branch of a constexpr if statement.
  assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) &&(static_cast <bool> ((!blockScope->isCXXThisCaptured
() || oldBlock->capturesCXXThis()) && "this pointer isn't captured in the old block"
) ? void (0) : __assert_fail ("(!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) && \"this pointer isn't captured in the old block\""
, "clang/lib/Sema/TreeTransform.h", 14660, __extension__ __PRETTY_FUNCTION__
))
         "this pointer isn't captured in the old block")(static_cast <bool> ((!blockScope->isCXXThisCaptured
() || oldBlock->capturesCXXThis()) && "this pointer isn't captured in the old block"
) ? void (0) : __assert_fail ("(!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) && \"this pointer isn't captured in the old block\""
, "clang/lib/Sema/TreeTransform.h", 14660, __extension__ __PRETTY_FUNCTION__
));
}
14662#endif

return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
                                  /*Scope=*/nullptr);
14666}

14668template<typename Derived>
14669ExprResult
14670TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
if (SrcExpr.isInvalid())
  return ExprError();

QualType Type = getDerived().TransformType(E->getType());

return SemaRef.BuildAsTypeExpr(SrcExpr.get(), Type, E->getBuiltinLoc(),
                               E->getRParenLoc());
14679}

14681template<typename Derived>
14682ExprResult
14683TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
bool ArgumentChanged = false;
SmallVector<Expr*, 8> SubExprs;
SubExprs.reserve(E->getNumSubExprs());
if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
                                SubExprs, &ArgumentChanged))
  return ExprError();

if (!getDerived().AlwaysRebuild() &&
    !ArgumentChanged)
  return E;

return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
                                      E->getOp(), E->getRParenLoc());
14697}

14699//===----------------------------------------------------------------------===//
14700// Type reconstruction
14701//===----------------------------------------------------------------------===//

14703template<typename Derived>
14704QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
                                                  SourceLocation Star) {
return SemaRef.BuildPointerType(PointeeType, Star,
                                getDerived().getBaseEntity());
14708}

14710template<typename Derived>
14711QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
                                                       SourceLocation Star) {
return SemaRef.BuildBlockPointerType(PointeeType, Star,
                                     getDerived().getBaseEntity());
14715}

14717template<typename Derived>
14718QualType
14719TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
                                           bool WrittenAsLValue,
                                           SourceLocation Sigil) {
return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
                                  Sigil, getDerived().getBaseEntity());
14724}

14726template<typename Derived>
14727QualType
14728TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
                                               QualType ClassType,
                                               SourceLocation Sigil) {
return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
                                      getDerived().getBaseEntity());
14733}

14735template<typename Derived>
14736QualType TreeTransform<Derived>::RebuildObjCTypeParamType(
         const ObjCTypeParamDecl *Decl,
         SourceLocation ProtocolLAngleLoc,
         ArrayRef<ObjCProtocolDecl *> Protocols,
         ArrayRef<SourceLocation> ProtocolLocs,
         SourceLocation ProtocolRAngleLoc) {
return SemaRef.BuildObjCTypeParamType(Decl,
                                      ProtocolLAngleLoc, Protocols,
                                      ProtocolLocs, ProtocolRAngleLoc,
                                      /*FailOnError=*/true);
14746}

14748template<typename Derived>
14749QualType TreeTransform<Derived>::RebuildObjCObjectType(
         QualType BaseType,
         SourceLocation Loc,
         SourceLocation TypeArgsLAngleLoc,
         ArrayRef<TypeSourceInfo *> TypeArgs,
         SourceLocation TypeArgsRAngleLoc,
         SourceLocation ProtocolLAngleLoc,
         ArrayRef<ObjCProtocolDecl *> Protocols,
         ArrayRef<SourceLocation> ProtocolLocs,
         SourceLocation ProtocolRAngleLoc) {
return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, TypeArgs,
                                   TypeArgsRAngleLoc, ProtocolLAngleLoc,
                                   Protocols, ProtocolLocs, ProtocolRAngleLoc,
                                   /*FailOnError=*/true,
                                   /*Rebuilding=*/true);
14764}

14766template<typename Derived>
14767QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
         QualType PointeeType,
         SourceLocation Star) {
return SemaRef.Context.getObjCObjectPointerType(PointeeType);
14771}

14773template<typename Derived>
14774QualType
14775TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
                                       ArrayType::ArraySizeModifier SizeMod,
                                       const llvm::APInt *Size,
                                       Expr *SizeExpr,
                                       unsigned IndexTypeQuals,
                                       SourceRange BracketsRange) {
if (SizeExpr || !Size)
  return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
                                IndexTypeQuals, BracketsRange,
                                getDerived().getBaseEntity());

QualType Types[] = {
  SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
  SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
  SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
};
QualType SizeType;
for (const auto &T : Types)
  if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) {
    SizeType = T;
    break;
  }

// Note that we can return a VariableArrayType here in the case where
// the element type was a dependent VariableArrayType.
IntegerLiteral *ArraySize
    = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType,
                             /*FIXME*/BracketsRange.getBegin());
return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
                              IndexTypeQuals, BracketsRange,
                              getDerived().getBaseEntity());
14806}

14808template<typename Derived>
14809QualType
14810TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
                                               ArrayType::ArraySizeModifier SizeMod,
                                               const llvm::APInt &Size,
                                               Expr *SizeExpr,
                                               unsigned IndexTypeQuals,
                                               SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
                                      IndexTypeQuals, BracketsRange);
14818}

14820template<typename Derived>
14821QualType
14822TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                               unsigned IndexTypeQuals,
                                                 SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
                                     IndexTypeQuals, BracketsRange);
14828}

14830template<typename Derived>
14831QualType
14832TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                               Expr *SizeExpr,
                                               unsigned IndexTypeQuals,
                                               SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
                                     SizeExpr,
                                     IndexTypeQuals, BracketsRange);
14840}

14842template<typename Derived>
14843QualType
14844TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
                                        ArrayType::ArraySizeModifier SizeMod,
                                                     Expr *SizeExpr,
                                                     unsigned IndexTypeQuals,
                                                 SourceRange BracketsRange) {
return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
                                     SizeExpr,
                                     IndexTypeQuals, BracketsRange);
14852}

14854template <typename Derived>
14855QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType(
  QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
return SemaRef.BuildAddressSpaceAttr(PointeeType, AddrSpaceExpr,
                                        AttributeLoc);
14859}

14861template <typename Derived>
14862QualType
14863TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
                                        unsigned NumElements,
                                        VectorType::VectorKind VecKind) {
// FIXME: semantic checking!
return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
14868}

14870template <typename Derived>
14871QualType TreeTransform<Derived>::RebuildDependentVectorType(
  QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc,
  VectorType::VectorKind VecKind) {
return SemaRef.BuildVectorType(ElementType, SizeExpr, AttributeLoc);
14875}

14877template<typename Derived>
14878QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
                                                    unsigned NumElements,
                                               SourceLocation AttributeLoc) {
llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
                        NumElements, true);
IntegerLiteral *VectorSize
  = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy,
                           AttributeLoc);
return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
14887}

14889template<typename Derived>
14890QualType
14891TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
                                                         Expr *SizeExpr,
                                                SourceLocation AttributeLoc) {
return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
14895}

14897template <typename Derived>
14898QualType TreeTransform<Derived>::RebuildConstantMatrixType(
  QualType ElementType, unsigned NumRows, unsigned NumColumns) {
return SemaRef.Context.getConstantMatrixType(ElementType, NumRows,
                                             NumColumns);
14902}

14904template <typename Derived>
14905QualType TreeTransform<Derived>::RebuildDependentSizedMatrixType(
  QualType ElementType, Expr *RowExpr, Expr *ColumnExpr,
  SourceLocation AttributeLoc) {
return SemaRef.BuildMatrixType(ElementType, RowExpr, ColumnExpr,
                               AttributeLoc);
14910}

14912template<typename Derived>
14913QualType TreeTransform<Derived>::RebuildFunctionProtoType(
  QualType T,
  MutableArrayRef<QualType> ParamTypes,
  const FunctionProtoType::ExtProtoInfo &EPI) {
return SemaRef.BuildFunctionType(T, ParamTypes,
                                 getDerived().getBaseLocation(),
                                 getDerived().getBaseEntity(),
                                 EPI);
14921}

14923template<typename Derived>
14924QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
return SemaRef.Context.getFunctionNoProtoType(T);
14926}

14928template<typename Derived>
14929QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc,
                                                          Decl *D) {
assert(D && "no decl found")(static_cast <bool> (D && "no decl found") ? void
 (0) : __assert_fail ("D && \"no decl found\"", "clang/lib/Sema/TreeTransform.h"
, 14931, __extension__ __PRETTY_FUNCTION__));
if (D->isInvalidDecl()) return QualType();

// FIXME: Doesn't account for ObjCInterfaceDecl!
if (auto *UPD = dyn_cast<UsingPackDecl>(D)) {
  // A valid resolved using typename pack expansion decl can have multiple
  // UsingDecls, but they must each have exactly one type, and it must be
  // the same type in every case. But we must have at least one expansion!
  if (UPD->expansions().empty()) {
    getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
        << UPD->isCXXClassMember() << UPD;
    return QualType();
  }

  // We might still have some unresolved types. Try to pick a resolved type
  // if we can. The final instantiation will check that the remaining
  // unresolved types instantiate to the type we pick.
  QualType FallbackT;
  QualType T;
  for (auto *E : UPD->expansions()) {
    QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
    if (ThisT.isNull())
      continue;
    else if (ThisT->getAs<UnresolvedUsingType>())
      FallbackT = ThisT;
    else if (T.isNull())
      T = ThisT;
    else
      assert(getSema().Context.hasSameType(ThisT, T) &&(static_cast <bool> (getSema().Context.hasSameType(ThisT
, T) && "mismatched resolved types in using pack expansion"
) ? void (0) : __assert_fail ("getSema().Context.hasSameType(ThisT, T) && \"mismatched resolved types in using pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 14960, __extension__ __PRETTY_FUNCTION__
))
             "mismatched resolved types in using pack expansion")(static_cast <bool> (getSema().Context.hasSameType(ThisT
, T) && "mismatched resolved types in using pack expansion"
) ? void (0) : __assert_fail ("getSema().Context.hasSameType(ThisT, T) && \"mismatched resolved types in using pack expansion\""
, "clang/lib/Sema/TreeTransform.h", 14960, __extension__ __PRETTY_FUNCTION__
));
  }
  return T.isNull() ? FallbackT : T;
} else if (auto *Using = dyn_cast<UsingDecl>(D)) {
  assert(Using->hasTypename() &&(static_cast <bool> (Using->hasTypename() &&
 "UnresolvedUsingTypenameDecl transformed to non-typename using"
) ? void (0) : __assert_fail ("Using->hasTypename() && \"UnresolvedUsingTypenameDecl transformed to non-typename using\""
, "clang/lib/Sema/TreeTransform.h", 14965, __extension__ __PRETTY_FUNCTION__
))
         "UnresolvedUsingTypenameDecl transformed to non-typename using")(static_cast <bool> (Using->hasTypename() &&
 "UnresolvedUsingTypenameDecl transformed to non-typename using"
) ? void (0) : __assert_fail ("Using->hasTypename() && \"UnresolvedUsingTypenameDecl transformed to non-typename using\""
, "clang/lib/Sema/TreeTransform.h", 14965, __extension__ __PRETTY_FUNCTION__
));

  // A valid resolved using typename decl points to exactly one type decl.
  assert(++Using->shadow_begin() == Using->shadow_end())(static_cast <bool> (++Using->shadow_begin() == Using
->shadow_end()) ? void (0) : __assert_fail ("++Using->shadow_begin() == Using->shadow_end()"
, "clang/lib/Sema/TreeTransform.h", 14968, __extension__ __PRETTY_FUNCTION__
));

  UsingShadowDecl *Shadow = *Using->shadow_begin();
  if (SemaRef.DiagnoseUseOfDecl(Shadow->getTargetDecl(), Loc))
    return QualType();
  return SemaRef.Context.getUsingType(
      Shadow, SemaRef.Context.getTypeDeclType(
                  cast<TypeDecl>(Shadow->getTargetDecl())));
} else {
  assert(isa<UnresolvedUsingTypenameDecl>(D) &&(static_cast <bool> (isa<UnresolvedUsingTypenameDecl
>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"
) ? void (0) : __assert_fail ("isa<UnresolvedUsingTypenameDecl>(D) && \"UnresolvedUsingTypenameDecl transformed to non-using decl\""
, "clang/lib/Sema/TreeTransform.h", 14978, __extension__ __PRETTY_FUNCTION__
))
         "UnresolvedUsingTypenameDecl transformed to non-using decl")(static_cast <bool> (isa<UnresolvedUsingTypenameDecl
>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"
) ? void (0) : __assert_fail ("isa<UnresolvedUsingTypenameDecl>(D) && \"UnresolvedUsingTypenameDecl transformed to non-using decl\""
, "clang/lib/Sema/TreeTransform.h", 14978, __extension__ __PRETTY_FUNCTION__
));
  return SemaRef.Context.getTypeDeclType(
      cast<UnresolvedUsingTypenameDecl>(D));
}
14982}

14984template <typename Derived>
14985QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, SourceLocation,
                                                     TypeOfKind Kind) {
return SemaRef.BuildTypeofExprType(E, Kind);
14988}

14990template<typename Derived>
14991QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying,
                                                 TypeOfKind Kind) {
return SemaRef.Context.getTypeOfType(Underlying, Kind);
14994}

14996template <typename Derived>
14997QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, SourceLocation) {
return SemaRef.BuildDecltypeType(E);
14999}

15001template<typename Derived>
15002QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
                                          UnaryTransformType::UTTKind UKind,
                                          SourceLocation Loc) {
return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
15006}

15008template<typename Derived>
15009QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
                                                    TemplateName Template,
                                           SourceLocation TemplateNameLoc,
                                   TemplateArgumentListInfo &TemplateArgs) {
return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
15014}

15016template<typename Derived>
15017QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
                                                 SourceLocation KWLoc) {
return SemaRef.BuildAtomicType(ValueType, KWLoc);
15020}

15022template<typename Derived>
15023QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
                                               SourceLocation KWLoc,
                                               bool isReadPipe) {
return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc)
                  : SemaRef.BuildWritePipeType(ValueType, KWLoc);
15028}

15030template <typename Derived>
15031QualType TreeTransform<Derived>::RebuildBitIntType(bool IsUnsigned,
                                                 unsigned NumBits,
                                                 SourceLocation Loc) {
llvm::APInt NumBitsAP(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
                      NumBits, true);
IntegerLiteral *Bits = IntegerLiteral::Create(SemaRef.Context, NumBitsAP,
                                              SemaRef.Context.IntTy, Loc);
return SemaRef.BuildBitIntType(IsUnsigned, Bits, Loc);
15039}

15041template <typename Derived>
15042QualType TreeTransform<Derived>::RebuildDependentBitIntType(
  bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc) {
return SemaRef.BuildBitIntType(IsUnsigned, NumBitsExpr, Loc);
15045}

15047template<typename Derived>
15048TemplateName
15049TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          bool TemplateKW,
                                          TemplateDecl *Template) {
return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
                                                TemplateName(Template));
15054}

15056template<typename Derived>
15057TemplateName
15058TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          SourceLocation TemplateKWLoc,
                                          const IdentifierInfo &Name,
                                          SourceLocation NameLoc,
                                          QualType ObjectType,
                                          NamedDecl *FirstQualifierInScope,
                                          bool AllowInjectedClassName) {
UnqualifiedId TemplateName;
TemplateName.setIdentifier(&Name, NameLoc);
Sema::TemplateTy Template;
getSema().ActOnTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc,
                            TemplateName, ParsedType::make(ObjectType),
                            /*EnteringContext=*/false, Template,
                            AllowInjectedClassName);
return Template.get();
15073}

15075template<typename Derived>
15076TemplateName
15077TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                          SourceLocation TemplateKWLoc,
                                          OverloadedOperatorKind Operator,
                                          SourceLocation NameLoc,
                                          QualType ObjectType,
                                          bool AllowInjectedClassName) {
UnqualifiedId Name;
// FIXME: Bogus location information.
SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
Sema::TemplateTy Template;
getSema().ActOnTemplateName(
    /*Scope=*/nullptr, SS, TemplateKWLoc, Name, ParsedType::make(ObjectType),
    /*EnteringContext=*/false, Template, AllowInjectedClassName);
return Template.get();
15092}

15094template<typename Derived>
15095ExprResult
15096TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
                                                 SourceLocation OpLoc,
                                                 Expr *OrigCallee,
                                                 Expr *First,
                                                 Expr *Second) {
Expr *Callee = OrigCallee->IgnoreParenCasts();
bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);

if (First->getObjectKind() == OK_ObjCProperty) {
  BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
  if (BinaryOperator::isAssignmentOp(Opc))
    return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc,
                                               First, Second);
  ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
  if (Result.isInvalid())
    return ExprError();
  First = Result.get();
}

if (Second && Second->getObjectKind() == OK_ObjCProperty) {
  ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
  if (Result.isInvalid())
    return ExprError();
  Second = Result.get();
}

// Determine whether this should be a builtin operation.
if (Op == OO_Subscript) {
  if (!First->getType()->isOverloadableType() &&
      !Second->getType()->isOverloadableType())
    return getSema().CreateBuiltinArraySubscriptExpr(
        First, Callee->getBeginLoc(), Second, OpLoc);
} else if (Op == OO_Arrow) {
  // It is possible that the type refers to a RecoveryExpr created earlier
  // in the tree transformation.
  if (First->getType()->isDependentType())
    return ExprError();
  // -> is never a builtin operation.
  return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
} else if (Second == nullptr || isPostIncDec) {
  if (!First->getType()->isOverloadableType() ||
      (Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) {
    // The argument is not of overloadable type, or this is an expression
    // of the form &Class::member, so try to create a built-in unary
    // operation.
    UnaryOperatorKind Opc
      = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);

    return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
  }
} else {
  if (!First->getType()->isOverloadableType() &&
      !Second->getType()->isOverloadableType()) {
    // Neither of the arguments is an overloadable type, so try to
    // create a built-in binary operation.
    BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
    ExprResult Result
      = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
    if (Result.isInvalid())
      return ExprError();

    return Result;
  }
}

// Compute the transformed set of functions (and function templates) to be
// used during overload resolution.
UnresolvedSet<16> Functions;
bool RequiresADL;

if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
  Functions.append(ULE->decls_begin(), ULE->decls_end());
  // If the overload could not be resolved in the template definition
  // (because we had a dependent argument), ADL is performed as part of
  // template instantiation.
  RequiresADL = ULE->requiresADL();
} else {
  // If we've resolved this to a particular non-member function, just call
  // that function. If we resolved it to a member function,
  // CreateOverloaded* will find that function for us.
  NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
  if (!isa<CXXMethodDecl>(ND))
    Functions.addDecl(ND);
  RequiresADL = false;
}

// Add any functions found via argument-dependent lookup.
Expr *Args[2] = { First, Second };
unsigned NumArgs = 1 + (Second != nullptr);

// Create the overloaded operator invocation for unary operators.
if (NumArgs == 1 || isPostIncDec) {
  UnaryOperatorKind Opc
    = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
  return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First,
                                         RequiresADL);
}

if (Op == OO_Subscript) {
  SourceLocation LBrace;
  SourceLocation RBrace;

  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
    DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
    LBrace = NameLoc.getCXXOperatorNameBeginLoc();
    RBrace = NameLoc.getCXXOperatorNameEndLoc();
  } else {
    LBrace = Callee->getBeginLoc();
    RBrace = OpLoc;
  }

  return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
                                                    First, Second);
}

// Create the overloaded operator invocation for binary operators.
BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
ExprResult Result = SemaRef.CreateOverloadedBinOp(
    OpLoc, Opc, Functions, Args[0], Args[1], RequiresADL);
if (Result.isInvalid())
  return ExprError();

return Result;
15219}

15221template<typename Derived>
15222ExprResult
15223TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
                                                   SourceLocation OperatorLoc,
                                                     bool isArrow,
                                                     CXXScopeSpec &SS,
                                                   TypeSourceInfo *ScopeType,
                                                     SourceLocation CCLoc,
                                                     SourceLocation TildeLoc,
                                      PseudoDestructorTypeStorage Destroyed) {
QualType BaseType = Base->getType();
if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
    (!isArrow && !BaseType->getAs<RecordType>()) ||
    (isArrow && BaseType->getAs<PointerType>() &&
     !BaseType->castAs<PointerType>()->getPointeeType()
                                            ->template getAs<RecordType>())){
  // This pseudo-destructor expression is still a pseudo-destructor.
  return SemaRef.BuildPseudoDestructorExpr(
      Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
      CCLoc, TildeLoc, Destroyed);
}

TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
               SemaRef.Context.getCanonicalType(DestroyedType->getType())));
DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
NameInfo.setNamedTypeInfo(DestroyedType);

// The scope type is now known to be a valid nested name specifier
// component. Tack it on to the end of the nested name specifier.
if (ScopeType) {
  if (!ScopeType->getType()->getAs<TagType>()) {
    getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
                   diag::err_expected_class_or_namespace)
        << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
    return ExprError();
  }
  SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
            CCLoc);
}

SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
return getSema().BuildMemberReferenceExpr(Base, BaseType,
                                          OperatorLoc, isArrow,
                                          SS, TemplateKWLoc,
                                          /*FIXME: FirstQualifier*/ nullptr,
                                          NameInfo,
                                          /*TemplateArgs*/ nullptr,
                                          /*S*/nullptr);
15270}

15272template<typename Derived>
15273StmtResult
15274TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
SourceLocation Loc = S->getBeginLoc();
CapturedDecl *CD = S->getCapturedDecl();
unsigned NumParams = CD->getNumParams();
unsigned ContextParamPos = CD->getContextParamPosition();
SmallVector<Sema::CapturedParamNameType, 4> Params;
for (unsigned I = 0; I < NumParams; ++I) {
  if (I != ContextParamPos) {
    Params.push_back(
           std::make_pair(
                CD->getParam(I)->getName(),
                getDerived().TransformType(CD->getParam(I)->getType())));
  } else {
    Params.push_back(std::make_pair(StringRef(), QualType()));
  }
}
getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
                                   S->getCapturedRegionKind(), Params);
StmtResult Body;
{
  Sema::CompoundScopeRAII CompoundScope(getSema());
  Body = getDerived().TransformStmt(S->getCapturedStmt());
}

if (Body.isInvalid()) {
  getSema().ActOnCapturedRegionError();
  return StmtError();
}

return getSema().ActOnCapturedRegionEnd(Body.get());
15304}

15306} // end namespace clang

15308#endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H

←

/build/source/clang/include/clang/Sema/Ownership.h

1//===- Ownership.h - Parser ownership helpers -------------------*- 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 contains classes for managing ownership of Stmt and Expr nodes.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_SEMA_OWNERSHIP_H
14#define LLVM_CLANG_SEMA_OWNERSHIP_H

16#include "clang/AST/Expr.h"
17#include "clang/Basic/LLVM.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include "llvm/Support/type_traits.h"
21#include <cassert>
22#include <cstddef>
23#include <cstdint>

25//===----------------------------------------------------------------------===//
26// OpaquePtr
27//===----------------------------------------------------------------------===//

29namespace clang {

31class CXXBaseSpecifier;
32class CXXCtorInitializer;
33class Decl;
34class Expr;
35class ParsedTemplateArgument;
36class QualType;
37class Stmt;
38class TemplateName;
39class TemplateParameterList;

/// Wrapper for void* pointer.
/// \tparam PtrTy Either a pointer type like 'T*' or a type that behaves like
///               a pointer.
///
/// This is a very simple POD type that wraps a pointer that the Parser
/// doesn't know about but that Sema or another client does.  The PtrTy
/// template argument is used to make sure that "Decl" pointers are not
/// compatible with "Type" pointers for example.
template <class PtrTy>
class OpaquePtr {
  void *Ptr = nullptr;

  explicit OpaquePtr(void *Ptr) : Ptr(Ptr) {}

  using Traits = llvm::PointerLikeTypeTraits<PtrTy>;

public:
  OpaquePtr(std::nullptr_t = nullptr) {}

  static OpaquePtr make(PtrTy P) { OpaquePtr OP; OP.set(P); return OP; }

  /// Returns plain pointer to the entity pointed by this wrapper.
  /// \tparam PointeeT Type of pointed entity.
  ///
  /// It is identical to getPtrAs<PointeeT*>.
  template <typename PointeeT> PointeeT* getPtrTo() const {
    return get();
  }

  /// Returns pointer converted to the specified type.
  /// \tparam PtrT Result pointer type.  There must be implicit conversion
  ///              from PtrTy to PtrT.
  ///
  /// In contrast to getPtrTo, this method allows the return type to be
  /// a smart pointer.
  template <typename PtrT> PtrT getPtrAs() const {
    return get();
  }

  PtrTy get() const {
    return Traits::getFromVoidPointer(Ptr);
  }

  void set(PtrTy P) {
    Ptr = Traits::getAsVoidPointer(P);
  }

  explicit operator bool() const { return Ptr != nullptr; }

  void *getAsOpaquePtr() const { return Ptr; }
  static OpaquePtr getFromOpaquePtr(void *P) { return OpaquePtr(P); }
};

/// UnionOpaquePtr - A version of OpaquePtr suitable for membership
/// in a union.
template <class T> struct UnionOpaquePtr {
  void *Ptr;

  static UnionOpaquePtr make(OpaquePtr<T> P) {
    UnionOpaquePtr OP = { P.getAsOpaquePtr() };
    return OP;
  }

  OpaquePtr<T> get() const { return OpaquePtr<T>::getFromOpaquePtr(Ptr); }
  operator OpaquePtr<T>() const { return get(); }

  UnionOpaquePtr &operator=(OpaquePtr<T> P) {
    Ptr = P.getAsOpaquePtr();
    return *this;
  }
};

113} // namespace clang

115namespace llvm {

template <class T>
struct PointerLikeTypeTraits<clang::OpaquePtr<T>> {
  static constexpr int NumLowBitsAvailable = 0;

  static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) {
    // FIXME: Doesn't work? return P.getAs< void >();
    return P.getAsOpaquePtr();
  }

  static inline clang::OpaquePtr<T> getFromVoidPointer(void *P) {
    return clang::OpaquePtr<T>::getFromOpaquePtr(P);
  }
};

131} // namespace llvm

133namespace clang {

// Basic
136class StreamingDiagnostic;

138// Determines whether the low bit of the result pointer for the
139// given UID is always zero. If so, ActionResult will use that bit
140// for it's "invalid" flag.
141template <class Ptr> struct IsResultPtrLowBitFree {
static const bool value = false;
};

/// ActionResult - This structure is used while parsing/acting on
/// expressions, stmts, etc.  It encapsulates both the object returned by
/// the action, plus a sense of whether or not it is valid.
/// When CompressInvalid is true, the "invalid" flag will be
/// stored in the low bit of the Val pointer.
template<class PtrTy,
         bool CompressInvalid = IsResultPtrLowBitFree<PtrTy>::value>
class ActionResult {
  PtrTy Val;
  bool Invalid;

public:
  ActionResult(bool Invalid = false) : Val(PtrTy()), Invalid(Invalid) {}
  ActionResult(PtrTy val) : Val(val), Invalid(false) {}
  ActionResult(const DiagnosticBuilder &) : Val(PtrTy()), Invalid(true) {}

  // These two overloads prevent void* -> bool conversions.
  ActionResult(const void *) = delete;
  ActionResult(volatile void *) = delete;

  bool isInvalid() const { return Invalid; }
  bool isUsable() const { return !Invalid && Val; }
  bool isUnset() const { return !Invalid && !Val; }

  PtrTy get() const { return Val; }
  template <typename T> T *getAs() { return static_cast<T*>(get()); }

  void set(PtrTy V) { Val = V; }

  const ActionResult &operator=(PtrTy RHS) {
    Val = RHS;
    Invalid = false;
    return *this;
  }
};

// This ActionResult partial specialization places the "invalid"
// flag into the low bit of the pointer.
template<typename PtrTy>
class ActionResult<PtrTy, true> {
  // A pointer whose low bit is 1 if this result is invalid, 0
  // otherwise.
  uintptr_t PtrWithInvalid;

  using PtrTraits = llvm::PointerLikeTypeTraits<PtrTy>;

public:
  ActionResult(bool Invalid = false)
      : PtrWithInvalid(static_cast<uintptr_t>(Invalid)) {}

  ActionResult(PtrTy V) {
    void *VP = PtrTraits::getAsVoidPointer(V);
    PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
    assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer")(static_cast <bool> ((PtrWithInvalid & 0x01) == 0 &&
 "Badly aligned pointer") ? void (0) : __assert_fail ("(PtrWithInvalid & 0x01) == 0 && \"Badly aligned pointer\""
, "clang/include/clang/Sema/Ownership.h", 198, __extension__ __PRETTY_FUNCTION__
));
  }

  ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) {}

  // These two overloads prevent void* -> bool conversions.
  ActionResult(const void *) = delete;
  ActionResult(volatile void *) = delete;

  bool isInvalid() const { return PtrWithInvalid & 0x01; }
  bool isUsable() const { return PtrWithInvalid > 0x01; }
  bool isUnset() const { return PtrWithInvalid == 0; }

  PtrTy get() const {
    void *VP = reinterpret_cast<void *>(PtrWithInvalid & ~0x01);
11
←
'VP' initialized here→
    return PtrTraits::getFromVoidPointer(VP);
12
←
Passing value via 1st parameter 'P'→
13
←
Returning pointer→
  }

  template <typename T> T *getAs() { return static_cast<T*>(get()); }

  void set(PtrTy V) {
    void *VP = PtrTraits::getAsVoidPointer(V);
    PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
    assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer")(static_cast <bool> ((PtrWithInvalid & 0x01) == 0 &&
 "Badly aligned pointer") ? void (0) : __assert_fail ("(PtrWithInvalid & 0x01) == 0 && \"Badly aligned pointer\""
, "clang/include/clang/Sema/Ownership.h", 221, __extension__ __PRETTY_FUNCTION__
));
  }

  const ActionResult &operator=(PtrTy RHS) {
    void *VP = PtrTraits::getAsVoidPointer(RHS);
    PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
    assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer")(static_cast <bool> ((PtrWithInvalid & 0x01) == 0 &&
 "Badly aligned pointer") ? void (0) : __assert_fail ("(PtrWithInvalid & 0x01) == 0 && \"Badly aligned pointer\""
, "clang/include/clang/Sema/Ownership.h", 227, __extension__ __PRETTY_FUNCTION__
));
    return *this;
  }

  // For types where we can fit a flag in with the pointer, provide
  // conversions to/from pointer type.
  static ActionResult getFromOpaquePointer(void *P) {
    ActionResult Result;
    Result.PtrWithInvalid = (uintptr_t)P;
    return Result;
  }
  void *getAsOpaquePointer() const { return (void*)PtrWithInvalid; }
};

/// An opaque type for threading parsed type information through the
/// parser.
using ParsedType = OpaquePtr<QualType>;
using UnionParsedType = UnionOpaquePtr<QualType>;

// We can re-use the low bit of expression, statement, base, and
// member-initializer pointers for the "invalid" flag of
// ActionResult.
template<> struct IsResultPtrLowBitFree<Expr*> {
  static const bool value = true;
};
template<> struct IsResultPtrLowBitFree<Stmt*> {
  static const bool value = true;
};
template<> struct IsResultPtrLowBitFree<CXXBaseSpecifier*> {
  static const bool value = true;
};
template<> struct IsResultPtrLowBitFree<CXXCtorInitializer*> {
  static const bool value = true;
};

using ExprResult = ActionResult<Expr *>;
using StmtResult = ActionResult<Stmt *>;
using TypeResult = ActionResult<ParsedType>;
using BaseResult = ActionResult<CXXBaseSpecifier *>;
using MemInitResult = ActionResult<CXXCtorInitializer *>;

using DeclResult = ActionResult<Decl *>;
using ParsedTemplateTy = OpaquePtr<TemplateName>;
using UnionParsedTemplateTy = UnionOpaquePtr<TemplateName>;

using MultiExprArg = MutableArrayRef<Expr *>;
using MultiStmtArg = MutableArrayRef<Stmt *>;
using ASTTemplateArgsPtr = MutableArrayRef<ParsedTemplateArgument>;
using MultiTypeArg = MutableArrayRef<ParsedType>;
using MultiTemplateParamsArg = MutableArrayRef<TemplateParameterList *>;

inline ExprResult ExprError() { return ExprResult(true); }
inline StmtResult StmtError() { return StmtResult(true); }
inline TypeResult TypeError() { return TypeResult(true); }

inline ExprResult ExprError(const StreamingDiagnostic &) {
  return ExprError();
}
inline StmtResult StmtError(const StreamingDiagnostic &) {
  return StmtError();
}

inline ExprResult ExprEmpty() { return ExprResult(false); }
inline StmtResult StmtEmpty() { return StmtResult(false); }

inline Expr *AssertSuccess(ExprResult R) {
  assert(!R.isInvalid() && "operation was asserted to never fail!")(static_cast <bool> (!R.isInvalid() && "operation was asserted to never fail!"
) ? void (0) : __assert_fail ("!R.isInvalid() && \"operation was asserted to never fail!\""
, "clang/include/clang/Sema/Ownership.h", 293, __extension__ __PRETTY_FUNCTION__
));
  return R.get();
}

inline Stmt *AssertSuccess(StmtResult R) {
  assert(!R.isInvalid() && "operation was asserted to never fail!")(static_cast <bool> (!R.isInvalid() && "operation was asserted to never fail!"
) ? void (0) : __assert_fail ("!R.isInvalid() && \"operation was asserted to never fail!\""
, "clang/include/clang/Sema/Ownership.h", 298, __extension__ __PRETTY_FUNCTION__
));
  return R.get();
}

302} // namespace clang

304#endif // LLVM_CLANG_SEMA_OWNERSHIP_H